gravitl/netmaker
1
1
Fork 0
mirror of https://github.com/gravitl/netmaker.git synced 2025-10-04 10:54:24 +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

109
controllers/nodeHttpController.go
View file

@ -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
@ -70,7 +69,7 @@ func authenticate(response http.ResponseWriter, request *http.Request) {
//Search DB for node with Mac Address. Ignore pending nodes (they should not be able to authenticate with API untill approved).
collection := mongoconn.Client.Database("netmaker").Collection("nodes")
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
var err = collection.FindOne(ctx, bson.M{ "macaddress": authRequest.MacAddress, "ispending": false }).Decode(&result)
var err = collection.FindOne(ctx, bson.M{"macaddress": authRequest.MacAddress, "ispending": false}).Decode(&result)
defer cancel()
@ -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.",
@ -247,7 +244,7 @@ func getNetworkNodes(w http.ResponseWriter, r *http.Request) {
cur, err := collection.Find(ctx, filter, options.Find().SetProjection(bson.M{"_id": 0}))
if err != nil {
returnErrorResponse(w,r,formatError(err, "internal"))
returnErrorResponse(w, r, formatError(err, "internal"))
return
}
@ -264,7 +261,7 @@ func getNetworkNodes(w http.ResponseWriter, r *http.Request) {
err := cur.Decode(&node)
if err != nil {
returnErrorResponse(w,r,formatError(err, "internal"))
returnErrorResponse(w, r, formatError(err, "internal"))
return
}
@ -274,7 +271,7 @@ func getNetworkNodes(w http.ResponseWriter, r *http.Request) {
//TODO: Another fatal error we should take care of.
if err := cur.Err(); err != nil {
returnErrorResponse(w,r,formatError(err, "internal"))
returnErrorResponse(w, r, formatError(err, "internal"))
return
}
@ -299,7 +296,7 @@ func getAllNodes(w http.ResponseWriter, r *http.Request) {
// Filter out them ID's again
cur, err := collection.Find(ctx, bson.M{}, options.Find().SetProjection(bson.M{"_id": 0}))
if err != nil {
returnErrorResponse(w,r,formatError(err, "internal"))
returnErrorResponse(w, r, formatError(err, "internal"))
return
}
@ -310,7 +307,7 @@ func getAllNodes(w http.ResponseWriter, r *http.Request) {
var node models.ReturnNode
err := cur.Decode(&node)
if err != nil {
returnErrorResponse(w,r,formatError(err, "internal"))
returnErrorResponse(w, r, formatError(err, "internal"))
return
}
// add node to our array
@ -319,7 +316,7 @@ func getAllNodes(w http.ResponseWriter, r *http.Request) {
//TODO: Fatal error
if err := cur.Err(); err != nil {
returnErrorResponse(w,r,formatError(err, "internal"))
returnErrorResponse(w, r, formatError(err, "internal"))
return
}
@ -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()
@ -376,7 +372,7 @@ func checkIn(w http.ResponseWriter, r *http.Request) {
defer cancel()
if err != nil {
returnErrorResponse(w,r,formatError(err, "internal"))
returnErrorResponse(w, r, formatError(err, "internal"))
return
}
@ -395,7 +391,7 @@ func getNode(w http.ResponseWriter, r *http.Request) {
node, err := GetNode(params["macaddress"], params["network"])
if err != nil {
returnErrorResponse(w,r,formatError(err, "internal"))
returnErrorResponse(w, r, formatError(err, "internal"))
return
}
w.WriteHeader(http.StatusOK)
@ -423,7 +419,7 @@ func getLastModified(w http.ResponseWriter, r *http.Request) {
defer cancel()
if err != nil {
returnErrorResponse(w,r,formatError(err, "internal"))
returnErrorResponse(w, r, formatError(err, "internal"))
return
}
@ -452,7 +448,7 @@ func createNode(w http.ResponseWriter, r *http.Request) {
networkexists, err := functions.NetworkExists(networkName)
if err != nil {
returnErrorResponse(w,r,formatError(err, "internal"))
returnErrorResponse(w, r, formatError(err, "internal"))
return
} else if !networkexists {
errorResponse = models.ErrorResponse{
@ -467,16 +463,15 @@ func createNode(w http.ResponseWriter, r *http.Request) {
//get node from body of request
err = json.NewDecoder(r.Body).Decode(&node)
if err != nil {
returnErrorResponse(w,r,formatError(err, "internal"))
returnErrorResponse(w, r, formatError(err, "internal"))
return
}
node.Network = networkName
network, err := node.GetNetwork()
if err != nil {
returnErrorResponse(w,r,formatError(err, "internal"))
returnErrorResponse(w, r, formatError(err, "internal"))
return
}
@ -500,13 +495,13 @@ func createNode(w http.ResponseWriter, r *http.Request) {
err = ValidateNode("create", networkName, node)
if err != nil {
returnErrorResponse(w,r,formatError(err, "badrequest"))
returnErrorResponse(w, r, formatError(err, "badrequest"))
return
}
node, err = CreateNode(node, networkName)
if err != nil {
returnErrorResponse(w,r,formatError(err, "internal"))
returnErrorResponse(w, r, formatError(err, "internal"))
return
}
w.WriteHeader(http.StatusOK)
@ -524,7 +519,7 @@ func uncordonNode(w http.ResponseWriter, r *http.Request) {
node, err := functions.GetNodeByMacAddress(params["network"], params["macaddress"])
if err != nil {
returnErrorResponse(w,r,formatError(err, "internal"))
returnErrorResponse(w, r, formatError(err, "internal"))
return
}
@ -551,7 +546,7 @@ func uncordonNode(w http.ResponseWriter, r *http.Request) {
defer cancel()
if err != nil {
returnErrorResponse(w,r,formatError(err, "internal"))
returnErrorResponse(w, r, formatError(err, "internal"))
return
}
@ -569,7 +564,7 @@ func createGateway(w http.ResponseWriter, r *http.Request) {
err := json.NewDecoder(r.Body).Decode(&gateway)
if err != nil {
returnErrorResponse(w,r,formatError(err, "internal"))
returnErrorResponse(w, r, formatError(err, "internal"))
return
}
gateway.NetID = params["network"]
@ -577,13 +572,13 @@ func createGateway(w http.ResponseWriter, r *http.Request) {
node, err := functions.GetNodeByMacAddress(params["network"], params["macaddress"])
if err != nil {
returnErrorResponse(w,r,formatError(err, "internal"))
returnErrorResponse(w, r, formatError(err, "internal"))
return
}
err = validateGateway(gateway)
if err != nil {
returnErrorResponse(w,r,formatError(err, "internal"))
returnErrorResponse(w, r, formatError(err, "internal"))
return
}
@ -628,16 +623,22 @@ func createGateway(w http.ResponseWriter, r *http.Request) {
defer cancel()
if err != nil {
returnErrorResponse(w,r,formatError(err, "internal"))
returnErrorResponse(w, r, formatError(err, "internal"))
return
}
err = SetNetworkNodesLastModified(params["network"])
if err != nil {
returnErrorResponse(w,r,formatError(err, "internal"))
returnErrorResponse(w, r, formatError(err, "internal"))
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")
@ -662,7 +660,7 @@ func deleteGateway(w http.ResponseWriter, r *http.Request) {
node, err := functions.GetNodeByMacAddress(params["network"], params["macaddress"])
if err != nil {
returnErrorResponse(w,r,formatError(err, "internal"))
returnErrorResponse(w, r, formatError(err, "internal"))
return
}
@ -699,13 +697,20 @@ func deleteGateway(w http.ResponseWriter, r *http.Request) {
defer cancel()
if err != nil {
returnErrorResponse(w,r,formatError(err, "internal"))
returnErrorResponse(w, r, formatError(err, "internal"))
return
}
err = SetNetworkNodesLastModified(params["network"])
if err != nil {
returnErrorResponse(w,r,formatError(err, "internal"))
returnErrorResponse(w, r, formatError(err, "internal"))
return
}
//Get updated values to return
node, err = functions.GetNodeByMacAddress(params["network"], params["macaddress"])
if err != nil {
returnErrorResponse(w, r, formatError(err, "internal"))
return
}
@ -713,7 +718,6 @@ func deleteGateway(w http.ResponseWriter, r *http.Request) {
json.NewEncoder(w).Encode(node)
}
func updateNode(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
@ -727,12 +731,10 @@ func updateNode(w http.ResponseWriter, r *http.Request) {
//start here
node, err := functions.GetNodeByMacAddress(params["network"], params["macaddress"])
if err != nil {
returnErrorResponse(w,r,formatError(err, "internal"))
returnErrorResponse(w, r, formatError(err, "internal"))
return
}
var nodechange models.Node
// we decode our body request params
@ -746,13 +748,13 @@ func updateNode(w http.ResponseWriter, r *http.Request) {
err = ValidateNode("update", params["network"], nodechange)
if err != nil {
returnErrorResponse(w,r,formatError(err, "badrequest"))
returnErrorResponse(w, r, formatError(err, "badrequest"))
return
}
node, err = UpdateNode(nodechange, node)
if err != nil {
returnErrorResponse(w,r,formatError(err, "internal"))
returnErrorResponse(w, r, formatError(err, "internal"))
return
}
w.WriteHeader(http.StatusOK)
@ -771,13 +773,12 @@ func deleteNode(w http.ResponseWriter, r *http.Request) {
success, err := DeleteNode(params["macaddress"], params["network"])
if err != nil {
returnErrorResponse(w,r,formatError(err, "internal"))
returnErrorResponse(w, r, formatError(err, "internal"))
return
} else if !success {
err = errors.New("Could not delete node " + params["macaddress"])
returnErrorResponse(w,r,formatError(err, "internal"))
returnErrorResponse(w, r, formatError(err, "internal"))
return
}
w.WriteHeader(http.StatusOK)
json.NewEncoder(w).Encode(params["macaddress"] + " deleted.")
returnSuccessResponse(w, r, params["macaddress"]+" deleted.")
}

14
controllers/responseHttp.go
View file

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

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