fixed node tests

This commit is contained in:
Matthew R Kasun 2021-09-09 13:59:43 -04:00
parent 977da36673
commit 8a0d688867

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, models.Node{}, node)
assert.EqualError(t, err, "unable to get record key")
})
t.Run("Success", func(t *testing.T) {
testnode := createTestNode()
gateway.NetID = "skynet"
gateway.NodeID = testnode.MacAddress
node, err := CreateEgressGateway(gateway)
assert.Nil(t, err)
assert.Equal(t, "yes", node.IsEgressGateway)
assert.Equal(t, gateway.Ranges, node.EgressGatewayRanges)
})
}
func TestDeleteEgressGateway(t *testing.T) {
var gateway models.EgressGatewayRequest
database.InitializeDatabase()
deleteAllNetworks()
createNet()
createTestNode()
testnode := createTestNode()
gateway.Interface = "eth0"
gateway.Ranges = []string{"10.100.100.0/24"}
gateway.NetID = "skynet"
gateway.NodeID = testnode.MacAddress
t.Run("Success", func(t *testing.T) {
node, err := CreateEgressGateway(gateway)
assert.Nil(t, err)
assert.Equal(t, "yes", node.IsEgressGateway)
assert.Equal(t, []string{"10.100.100.0/24"}, node.EgressGatewayRanges)
node, err = DeleteEgressGateway(gateway.NetID, gateway.NodeID)
assert.Nil(t, err)
assert.Equal(t, "no", node.IsEgressGateway)
assert.Equal(t, []string([]string{}), node.EgressGatewayRanges)
assert.Equal(t, "", node.PostUp)
assert.Equal(t, "", node.PostDown)
})
t.Run("NotGateway", func(t *testing.T) {
node, err := DeleteEgressGateway(gateway.NetID, gateway.NodeID)
assert.Nil(t, err)
assert.Equal(t, "no", node.IsEgressGateway)
assert.Equal(t, []string([]string{}), node.EgressGatewayRanges)
assert.Equal(t, "", node.PostUp)
assert.Equal(t, "", node.PostDown)
})
t.Run("BadNode", func(t *testing.T) {
node, err := DeleteEgressGateway(gateway.NetID, "01:02:03")
assert.EqualError(t, err, "no result found")
assert.Equal(t, models.Node{}, node)
})
t.Run("BadNet", func(t *testing.T) {
node, err := DeleteEgressGateway("badnet", gateway.NodeID)
assert.EqualError(t, err, "no result found")
assert.Equal(t, models.Node{}, node)
})
}
func TestGetNetworkNodes(t *testing.T) {
database.InitializeDatabase()
deleteAllNetworks()
createNet()
t.Run("BadNet", func(t *testing.T) {
node, err := GetNetworkNodes("badnet")
assert.Nil(t, err)
assert.Equal(t, []models.Node{}, node)
//assert.Equal(t, "mongo: no documents in result", err.Error()) //assert.Equal(t, "mongo: no documents in result", err.Error())
// }) })
// t.Run("BadMac", func(t *testing.T) { t.Run("NoNodes", func(t *testing.T) {
// resp, err := CheckIn("skynet", "01:02:03") node, err := GetNetworkNodes("skynet")
// assert.NotNil(t, err) assert.Nil(t, err)
// assert.Equal(t, models.Node{}, resp) assert.Equal(t, []models.Node{}, node)
// assert.Equal(t, "mongo: no documents in result", err.Error()) })
// }) t.Run("Success", func(t *testing.T) {
// t.Run("Success", func(t *testing.T) { createTestNode()
// resp, err := CheckIn("skynet", node.MacAddress) node, err := GetNetworkNodes("skynet")
// assert.Nil(t, err) assert.Nil(t, err)
// assert.Greater(t, resp.LastCheckIn, node.LastCheckIn) assert.NotEqual(t, []models.Node(nil), node)
// }) })
//}
//func TestCreateEgressGateway(t *testing.T) { }
// var gateway models.EgressGatewayRequest func TestUncordonNode(t *testing.T) {
// gateway.Interface = "eth0" database.InitializeDatabase()
// gateway.Ranges = []string{"10.100.100.0/24"} deleteAllNetworks()
// deleteNet(t) createNet()
// createNet() node := createTestNode()
// t.Run("NoNodes", func(t *testing.T) { t.Run("BadNet", func(t *testing.T) {
// node, err := CreateEgressGateway(gateway) resp, err := UncordonNode("badnet", node.MacAddress)
// assert.NotNil(t, err) assert.Equal(t, models.Node{}, resp)
// assert.Equal(t, models.Node{}, node) assert.EqualError(t, err, "no result found")
// assert.Equal(t, "mongo: no documents in result", err.Error()) })
// }) t.Run("BadMac", func(t *testing.T) {
// t.Run("Success", func(t *testing.T) { resp, err := UncordonNode("skynet", "01:02:03")
// testnode := createTestNode(t) assert.Equal(t, models.Node{}, resp)
// gateway.NetID = "skynet" assert.EqualError(t, err, "no result found")
// gateway.NodeID = testnode.MacAddress })
// t.Run("Success", func(t *testing.T) {
// node, err := CreateEgressGateway(gateway) resp, err := UncordonNode("skynet", node.MacAddress)
// assert.Nil(t, err) assert.Nil(t, err)
// assert.Equal(t, true, node.IsEgressGateway) assert.Equal(t, "no", resp.IsPending)
// assert.Equal(t, "10.100.100.0/24", node.EgressGatewayRange) })
// })
// }
//} func TestValidateEgressGateway(t *testing.T) {
//func TestDeleteEgressGateway(t *testing.T) { var gateway models.EgressGatewayRequest
// var gateway models.EgressGatewayRequest t.Run("EmptyRange", func(t *testing.T) {
// deleteNet(t) gateway.Interface = "eth0"
// createNet() gateway.Ranges = []string{}
// createTestNode(t) err := ValidateEgressGateway(gateway)
// testnode := createTestNode(t) assert.EqualError(t, err, "IP Ranges Cannot Be Empty")
// gateway.Interface = "eth0" })
// gateway.Ranges = []string{"10.100.100.0/24"} t.Run("EmptyInterface", func(t *testing.T) {
// gateway.NetID = "skynet" gateway.Interface = ""
// gateway.NodeID = testnode.MacAddress err := ValidateEgressGateway(gateway)
// t.Run("Success", func(t *testing.T) { assert.NotNil(t, err)
// node, err := CreateEgressGateway(gateway) assert.Equal(t, "Interface cannot be empty", err.Error())
// assert.Nil(t, err) })
// assert.Equal(t, true, node.IsEgressGateway) t.Run("Success", func(t *testing.T) {
// assert.Equal(t, []string{"10.100.100.0/24"}, node.EgressGatewayRanges) gateway.Interface = "eth0"
// node, err = DeleteEgressGateway(gateway.NetID, gateway.NodeID) gateway.Ranges = []string{"10.100.100.0/24"}
// assert.Nil(t, err) err := ValidateEgressGateway(gateway)
// assert.Equal(t, false, node.IsEgressGateway) assert.Nil(t, err)
// assert.Equal(t, "", node.EgressGatewayRanges) })
// assert.Equal(t, "", node.PostUp) }
// assert.Equal(t, "", node.PostDown)
// })
// t.Run("NotGateway", func(t *testing.T) {
// node, err := DeleteEgressGateway(gateway.NetID, gateway.NodeID)
// assert.Nil(t, err)
// assert.Equal(t, false, node.IsEgressGateway)
// assert.Equal(t, "", node.EgressGatewayRanges)
// assert.Equal(t, "", node.PostUp)
// assert.Equal(t, "", node.PostDown)
// })
// t.Run("BadNode", func(t *testing.T) {
// node, err := DeleteEgressGateway(gateway.NetID, "01:02:03")
// assert.NotNil(t, err)
// assert.Equal(t, "mongo: no documents in result", err.Error())
// assert.Equal(t, models.Node{}, node)
// })
// t.Run("BadNet", func(t *testing.T) {
// node, err := DeleteEgressGateway("badnet", gateway.NodeID)
// assert.NotNil(t, err)
// assert.Equal(t, "mongo: no documents in result", err.Error())
// assert.Equal(t, models.Node{}, node)
// })
//
//}
//func TestGetLastModified(t *testing.T) {
// deleteNet(t)
// createNet()
// createTestNode(t)
// t.Run("BadNet", func(t *testing.T) {
// network, err := GetLastModified("badnet")
// assert.NotNil(t, err)
// assert.Equal(t, models.Network{}, network)
// assert.Equal(t, "mongo: no documents in result", err.Error())
// })
// t.Run("Success", func(t *testing.T) {
// network, err := GetLastModified("skynet")
// assert.Nil(t, err)
// assert.NotEqual(t, models.Network{}, network)
// })
//}
//func TestGetNetworkNodes(t *testing.T) {
// deleteNet(t)
// createNet()
// t.Run("BadNet", func(t *testing.T) {
// node, err := GetNetworkNodes("badnet")
// assert.Nil(t, err)
// assert.Equal(t, []models.Node(nil), node)
// //assert.Equal(t, "mongo: no documents in result", err.Error())
// })
// t.Run("NoNodes", func(t *testing.T) {
// node, err := GetNetworkNodes("skynet")
// assert.Nil(t, err)
// assert.Equal(t, []models.Node(nil), node)
// })
// t.Run("Success", func(t *testing.T) {
// createTestNode(t)
// node, err := GetNetworkNodes("skynet")
// assert.Nil(t, err)
// assert.NotEqual(t, []models.Node(nil), node)
// })
//
//}
//func TestUncordonNode(t *testing.T) {
// deleteNet(t)
// createNet()
// 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) {
////} ////}