yanic/database/influxdb/node_test.go

220 lines
5.2 KiB
Go
Raw Normal View History

package influxdb
import (
"testing"
2019-01-15 20:19:55 +01:00
"github.com/influxdata/influxdb1-client/v2"
"github.com/stretchr/testify/assert"
2017-03-03 16:19:35 +01:00
"github.com/FreifunkBremen/yanic/data"
"github.com/FreifunkBremen/yanic/runtime"
)
func TestToInflux(t *testing.T) {
assert := assert.New(t)
node := &runtime.Node{
Statistics: &data.Statistics{
NodeID: "deadbeef",
LoadAverage: 0.5,
2018-05-06 00:11:01 +02:00
ProcStats: &data.ProcStats{
CPU: data.ProcStatsCPU{
User: 1,
},
ContextSwitches: 3,
},
Wireless: data.WirelessStatistics{
&data.WirelessAirtime{Frequency: 5500},
},
Traffic: struct {
Tx *data.Traffic `json:"tx"`
Rx *data.Traffic `json:"rx"`
Forward *data.Traffic `json:"forward"`
MgmtTx *data.Traffic `json:"mgmt_tx"`
MgmtRx *data.Traffic `json:"mgmt_rx"`
}{
Tx: &data.Traffic{Dropped: 1321},
Rx: &data.Traffic{Bytes: 1213},
Forward: &data.Traffic{Bytes: 1322},
MgmtTx: &data.Traffic{Packets: 2327},
MgmtRx: &data.Traffic{Bytes: 2331},
},
MeshVPN: &data.MeshVPN{
Groups: map[string]*data.MeshVPNPeerGroup{
2018-01-13 16:40:23 +01:00
"ffhb": {
Peers: map[string]*data.MeshVPNPeerLink{
2018-01-13 16:40:23 +01:00
"vpn01": {Established: 3},
"vpn02": {},
2017-01-21 04:24:04 +01:00
"trash": nil,
2018-01-13 16:40:23 +01:00
"vpn03": {Established: 0},
},
},
},
},
},
Nodeinfo: &data.Nodeinfo{
NodeID: "deadbeef",
Owner: &data.Owner{
Contact: "nobody",
},
2017-11-20 12:22:52 +01:00
System: data.System{
SiteCode: "ffhb",
DomainCode: "city",
2017-11-20 12:22:52 +01:00
},
Wireless: &data.Wireless{
TxPower24: 3,
Channel24: 4,
},
Network: data.Network{
Mac: "DEADMAC",
},
Software: data.Software{
Autoupdater: struct {
Enabled bool `json:"enabled,omitempty"`
Branch string `json:"branch,omitempty"`
}{
Enabled: true,
Branch: "testing",
},
},
},
Neighbours: &data.Neighbours{
NodeID: "deadbeef",
Batadv: map[string]data.BatadvNeighbours{
2018-01-13 16:40:23 +01:00
"a-interface": {
Neighbours: map[string]data.BatmanLink{
2018-01-13 16:40:23 +01:00
"BAFF1E5": {
Tq: 204,
},
},
},
},
LLDP: map[string]data.LLDPNeighbours{
2018-01-13 16:40:23 +01:00
"b-interface": {},
},
},
}
2018-01-13 16:54:48 +01:00
neighbour := &runtime.Node{
Nodeinfo: &data.Nodeinfo{
NodeID: "foobar",
Network: data.Network{
Mac: "BAFF1E5",
},
Software: data.Software{
Autoupdater: struct {
Enabled bool `json:"enabled,omitempty"`
Branch string `json:"branch,omitempty"`
}{
Enabled: false,
},
},
},
Statistics: &data.Statistics{
NodeID: "foobar",
},
}
// do not add a empty statistics of a node
droppednode := &runtime.Node{
Nodeinfo: &data.Nodeinfo{
NodeID: "notfound",
Network: data.Network{
Mac: "instats",
},
},
Statistics: &data.Statistics{},
}
2018-01-13 16:54:48 +01:00
points := testPoints(node, neighbour, droppednode)
var fields map[string]interface{}
var tags map[string]string
assert.Len(points, 3)
// first point contains the neighbour
sPoint := points[0]
tags = sPoint.Tags()
fields, _ = sPoint.Fields()
assert.EqualValues("deadbeef", tags["nodeid"])
assert.EqualValues("nobody", tags["owner"])
assert.EqualValues("testing", tags["autoupdater"])
assert.EqualValues("ffhb", tags["site"])
assert.EqualValues("city", tags["domain"])
assert.EqualValues(0.5, fields["load"])
assert.EqualValues(0, fields["neighbours.lldp"])
assert.EqualValues(1, fields["neighbours.batadv"])
assert.EqualValues(1, fields["neighbours.vpn"])
assert.EqualValues(1, fields["neighbours.total"])
assert.EqualValues(uint32(3), fields["wireless.txpower24"])
assert.EqualValues(uint32(5500), fields["airtime11a.frequency"])
assert.EqualValues("", tags["frequency5500"])
assert.EqualValues(int64(1213), fields["traffic.rx.bytes"])
assert.EqualValues(float64(1321), fields["traffic.tx.dropped"])
assert.EqualValues(int64(1322), fields["traffic.forward.bytes"])
assert.EqualValues(int64(2331), fields["traffic.mgmt_rx.bytes"])
assert.EqualValues(float64(2327), fields["traffic.mgmt_tx.packets"])
// second point contains the link
nPoint := points[1]
tags = nPoint.Tags()
fields, _ = nPoint.Fields()
assert.EqualValues("link", nPoint.Name())
assert.EqualValues(map[string]string{
"source.id": "deadbeef",
"source.addr": "a-interface",
"target.id": "foobar",
"target.addr": "BAFF1E5",
}, tags)
assert.EqualValues(80, fields["tq"])
// third point contains the neighbour
nPoint = points[2]
tags = nPoint.Tags()
assert.EqualValues("disabled", tags["autoupdater"])
}
// Processes data and returns the InfluxDB points
func testPoints(nodes ...*runtime.Node) (points []*client.Point) {
// Create dummy client
influxClient, err := client.NewHTTPClient(client.HTTPConfig{Addr: "http://127.0.0.1"})
if err != nil {
panic(err)
}
nodesList := runtime.NewNodes(&runtime.NodesConfig{})
// Create dummy connection
conn := &Connection{
points: make(chan *client.Point),
client: influxClient,
}
for _, node := range nodes {
nodesList.AddNode(node)
}
// Process data
go func() {
for _, node := range nodes {
conn.InsertNode(node)
if node.Neighbours != nil {
for _, link := range nodesList.NodeLinks(node) {
conn.InsertLink(&link, node.Lastseen.GetTime())
}
}
}
conn.Close()
}()
// Read points
for point := range conn.points {
points = append(points, point)
}
return
}