gravitl/netmaker
1
1
Fork 0
mirror of https://github.com/gravitl/netmaker.git synced 2025-02-25 16:44:01 +08:00
Code Issues Projects Releases Packages Wiki Activity

fixed node tests

Browse source
This commit is contained in:
Matthew R Kasun 2021-09-09 13:59:43 -04:00
parent 977da36673
commit 8a0d688867
1 changed files with 139 additions and 174 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

313
controllers/nodeHttpController_test.go
View file

@ -1,183 +1,148 @@
package controller package controller
import ( import (
"testing"
"github.com/gravitl/netmaker/database"
"github.com/gravitl/netmaker/models" "github.com/gravitl/netmaker/models"
"github.com/stretchr/testify/assert"
) )
//func TestCheckIn(t *testing.T) { func TestCreateEgressGateway(t *testing.T) {
// deleteNet(t) var gateway models.EgressGatewayRequest
// createNet() gateway.Interface = "eth0"
// node := createTestNode(t) gateway.Ranges = []string{"10.100.100.0/24"}
// time.Sleep(time.Second * 1) database.InitializeDatabase()
// t.Run("BadNet", func(t *testing.T) { deleteAllNetworks()
// resp, err := CheckIn("badnet", node.MacAddress) createNet()
// assert.NotNil(t, err) t.Run("NoNodes", func(t *testing.T) {
// assert.Equal(t, models.Node{}, resp) node, err := CreateEgressGateway(gateway)
// assert.Equal(t, "mongo: no documents in result", err.Error()) assert.Equal(t, models.Node{}, node)
// }) assert.EqualError(t, err, "unable to get record key")
// t.Run("BadMac", func(t *testing.T) { })
// resp, err := CheckIn("skynet", "01:02:03") t.Run("Success", func(t *testing.T) {
// assert.NotNil(t, err) testnode := createTestNode()
// assert.Equal(t, models.Node{}, resp) gateway.NetID = "skynet"
// assert.Equal(t, "mongo: no documents in result", err.Error()) gateway.NodeID = testnode.MacAddress
// })
// t.Run("Success", func(t *testing.T) { node, err := CreateEgressGateway(gateway)
// resp, err := CheckIn("skynet", node.MacAddress) assert.Nil(t, err)
// assert.Nil(t, err) assert.Equal(t, "yes", node.IsEgressGateway)
// assert.Greater(t, resp.LastCheckIn, node.LastCheckIn) assert.Equal(t, gateway.Ranges, node.EgressGatewayRanges)
// }) })
//}
//func TestCreateEgressGateway(t *testing.T) { }
// var gateway models.EgressGatewayRequest func TestDeleteEgressGateway(t *testing.T) {
// gateway.Interface = "eth0" var gateway models.EgressGatewayRequest
// gateway.Ranges = []string{"10.100.100.0/24"} database.InitializeDatabase()
// deleteNet(t) deleteAllNetworks()
// createNet() createNet()
// t.Run("NoNodes", func(t *testing.T) { createTestNode()
// node, err := CreateEgressGateway(gateway) testnode := createTestNode()
// assert.NotNil(t, err) gateway.Interface = "eth0"
// assert.Equal(t, models.Node{}, node) gateway.Ranges = []string{"10.100.100.0/24"}
// assert.Equal(t, "mongo: no documents in result", err.Error()) gateway.NetID = "skynet"
// }) gateway.NodeID = testnode.MacAddress
// t.Run("Success", func(t *testing.T) { t.Run("Success", func(t *testing.T) {
// testnode := createTestNode(t) node, err := CreateEgressGateway(gateway)
// gateway.NetID = "skynet" assert.Nil(t, err)
// gateway.NodeID = testnode.MacAddress assert.Equal(t, "yes", node.IsEgressGateway)
// assert.Equal(t, []string{"10.100.100.0/24"}, node.EgressGatewayRanges)
// node, err := CreateEgressGateway(gateway) node, err = DeleteEgressGateway(gateway.NetID, gateway.NodeID)
// assert.Nil(t, err) assert.Nil(t, err)
// assert.Equal(t, true, node.IsEgressGateway) assert.Equal(t, "no", node.IsEgressGateway)
// assert.Equal(t, "10.100.100.0/24", node.EgressGatewayRange) assert.Equal(t, []string([]string{}), node.EgressGatewayRanges)
// }) assert.Equal(t, "", node.PostUp)
// assert.Equal(t, "", node.PostDown)
//} })
//func TestDeleteEgressGateway(t *testing.T) { t.Run("NotGateway", func(t *testing.T) {
// var gateway models.EgressGatewayRequest node, err := DeleteEgressGateway(gateway.NetID, gateway.NodeID)
// deleteNet(t) assert.Nil(t, err)
// createNet() assert.Equal(t, "no", node.IsEgressGateway)
// createTestNode(t) assert.Equal(t, []string([]string{}), node.EgressGatewayRanges)
// testnode := createTestNode(t) assert.Equal(t, "", node.PostUp)
// gateway.Interface = "eth0" assert.Equal(t, "", node.PostDown)
// gateway.Ranges = []string{"10.100.100.0/24"} })
// gateway.NetID = "skynet" t.Run("BadNode", func(t *testing.T) {
// gateway.NodeID = testnode.MacAddress node, err := DeleteEgressGateway(gateway.NetID, "01:02:03")
// t.Run("Success", func(t *testing.T) { assert.EqualError(t, err, "no result found")
// node, err := CreateEgressGateway(gateway) assert.Equal(t, models.Node{}, node)
// assert.Nil(t, err) })
// assert.Equal(t, true, node.IsEgressGateway) t.Run("BadNet", func(t *testing.T) {
// assert.Equal(t, []string{"10.100.100.0/24"}, node.EgressGatewayRanges) node, err := DeleteEgressGateway("badnet", gateway.NodeID)
// node, err = DeleteEgressGateway(gateway.NetID, gateway.NodeID) assert.EqualError(t, err, "no result found")
// assert.Nil(t, err) assert.Equal(t, models.Node{}, node)
// assert.Equal(t, false, node.IsEgressGateway) })
// assert.Equal(t, "", node.EgressGatewayRanges)
// assert.Equal(t, "", node.PostUp) }
// assert.Equal(t, "", node.PostDown)
// }) func TestGetNetworkNodes(t *testing.T) {
// t.Run("NotGateway", func(t *testing.T) { database.InitializeDatabase()
// node, err := DeleteEgressGateway(gateway.NetID, gateway.NodeID) deleteAllNetworks()
// assert.Nil(t, err) createNet()
// assert.Equal(t, false, node.IsEgressGateway) t.Run("BadNet", func(t *testing.T) {
// assert.Equal(t, "", node.EgressGatewayRanges) node, err := GetNetworkNodes("badnet")
// assert.Equal(t, "", node.PostUp) assert.Nil(t, err)
// assert.Equal(t, "", node.PostDown) assert.Equal(t, []models.Node{}, node)
// }) //assert.Equal(t, "mongo: no documents in result", err.Error())
// t.Run("BadNode", func(t *testing.T) { })
// node, err := DeleteEgressGateway(gateway.NetID, "01:02:03") t.Run("NoNodes", func(t *testing.T) {
// assert.NotNil(t, err) node, err := GetNetworkNodes("skynet")
// assert.Equal(t, "mongo: no documents in result", err.Error()) assert.Nil(t, err)
// assert.Equal(t, models.Node{}, node) assert.Equal(t, []models.Node{}, node)
// }) })
// t.Run("BadNet", func(t *testing.T) { t.Run("Success", func(t *testing.T) {
// node, err := DeleteEgressGateway("badnet", gateway.NodeID) createTestNode()
// assert.NotNil(t, err) node, err := GetNetworkNodes("skynet")
// assert.Equal(t, "mongo: no documents in result", err.Error()) assert.Nil(t, err)
// assert.Equal(t, models.Node{}, node) assert.NotEqual(t, []models.Node(nil), node)
// }) })
//
//} }
//func TestGetLastModified(t *testing.T) { func TestUncordonNode(t *testing.T) {
// deleteNet(t) database.InitializeDatabase()
// createNet() deleteAllNetworks()
// createTestNode(t) createNet()
// t.Run("BadNet", func(t *testing.T) { node := createTestNode()
// network, err := GetLastModified("badnet") t.Run("BadNet", func(t *testing.T) {
// assert.NotNil(t, err) resp, err := UncordonNode("badnet", node.MacAddress)
// assert.Equal(t, models.Network{}, network) assert.Equal(t, models.Node{}, resp)
// assert.Equal(t, "mongo: no documents in result", err.Error()) assert.EqualError(t, err, "no result found")
// }) })
// t.Run("Success", func(t *testing.T) { t.Run("BadMac", func(t *testing.T) {
// network, err := GetLastModified("skynet") resp, err := UncordonNode("skynet", "01:02:03")
// assert.Nil(t, err) assert.Equal(t, models.Node{}, resp)
// assert.NotEqual(t, models.Network{}, network) assert.EqualError(t, err, "no result found")
// }) })
//} t.Run("Success", func(t *testing.T) {
//func TestGetNetworkNodes(t *testing.T) { resp, err := UncordonNode("skynet", node.MacAddress)
// deleteNet(t) assert.Nil(t, err)
// createNet() assert.Equal(t, "no", resp.IsPending)
// t.Run("BadNet", func(t *testing.T) { })
// node, err := GetNetworkNodes("badnet")
// assert.Nil(t, err) }
// assert.Equal(t, []models.Node(nil), node) func TestValidateEgressGateway(t *testing.T) {
// //assert.Equal(t, "mongo: no documents in result", err.Error()) var gateway models.EgressGatewayRequest
// }) t.Run("EmptyRange", func(t *testing.T) {
// t.Run("NoNodes", func(t *testing.T) { gateway.Interface = "eth0"
// node, err := GetNetworkNodes("skynet") gateway.Ranges = []string{}
// assert.Nil(t, err) err := ValidateEgressGateway(gateway)
// assert.Equal(t, []models.Node(nil), node) assert.EqualError(t, err, "IP Ranges Cannot Be Empty")
// }) })
// t.Run("Success", func(t *testing.T) { t.Run("EmptyInterface", func(t *testing.T) {
// createTestNode(t) gateway.Interface = ""
// node, err := GetNetworkNodes("skynet") err := ValidateEgressGateway(gateway)
// assert.Nil(t, err) assert.NotNil(t, err)
// assert.NotEqual(t, []models.Node(nil), node) assert.Equal(t, "Interface cannot be empty", err.Error())
// }) })
// t.Run("Success", func(t *testing.T) {
//} gateway.Interface = "eth0"
//func TestUncordonNode(t *testing.T) { gateway.Ranges = []string{"10.100.100.0/24"}
// deleteNet(t) err := ValidateEgressGateway(gateway)
// createNet() assert.Nil(t, err)
// node := createTestNode(t) })
// t.Run("BadNet", func(t *testing.T) { }
// resp, err := UncordonNode("badnet", node.MacAddress)
// assert.NotNil(t, err)
// assert.Equal(t, models.Node{}, resp)
// assert.Equal(t, "mongo: no documents in result", err.Error())
// })
// t.Run("BadMac", func(t *testing.T) {
// resp, err := UncordonNode("skynet", "01:02:03")
// assert.NotNil(t, err)
// assert.Equal(t, models.Node{}, resp)
// assert.Equal(t, "mongo: no documents in result", err.Error())
// })
// t.Run("Success", func(t *testing.T) {
// resp, err := CheckIn("skynet", node.MacAddress)
// assert.Nil(t, err)
// assert.Equal(t, false, resp.IsPending)
// })
//
//}
//func TestValidateEgressGateway(t *testing.T) {
// var gateway models.EgressGatewayRequest
// t.Run("EmptyRange", func(t *testing.T) {
// gateway.Interface = "eth0"
// gateway.Ranges = []string{}
// err := ValidateEgressGateway(gateway)
// assert.NotNil(t, err)
// assert.Equal(t, "IP Range Not Valid", err.Error())
// })
// t.Run("EmptyInterface", func(t *testing.T) {
// gateway.Interface = ""
// err := ValidateEgressGateway(gateway)
// assert.NotNil(t, err)
// assert.Equal(t, "Interface cannot be empty", err.Error())
// })
// t.Run("Success", func(t *testing.T) {
// gateway.Interface = "eth0"
// gateway.Ranges = []string{"10.100.100.0/24"}
// err := ValidateEgressGateway(gateway)
// assert.Nil(t, err)
// })
//}
// //
////func TestUpdateNode(t *testing.T) { ////func TestUpdateNode(t *testing.T) {
////} ////}