yanic/runtime/nodes_test.go

259 lines
6.1 KiB
Go
Raw Normal View History

package runtime
2016-03-20 18:30:44 +01:00
import (
"io/ioutil"
"os"
"testing"
2016-10-08 11:52:11 +02:00
"time"
2016-03-20 18:30:44 +01:00
"github.com/stretchr/testify/assert"
2017-03-03 16:19:35 +01:00
"github.com/FreifunkBremen/yanic/data"
"github.com/FreifunkBremen/yanic/lib/jsontime"
2016-03-20 18:30:44 +01:00
)
2016-10-08 11:52:11 +02:00
func TestExpire(t *testing.T) {
assert := assert.New(t)
config := &NodesConfig{}
config.OfflineAfter.Duration = time.Minute * 10
// to get default (100%) path of testing
// config.PruneAfter.Duration = time.Hour * 24 * 6
2016-10-08 11:52:11 +02:00
nodes := &Nodes{
config: config,
List: make(map[string]*Node),
ifaceToNodeID: make(map[string]string),
2016-10-08 11:52:11 +02:00
}
nodes.Update("expire", &data.ResponseData{}) // should expire
nodes.Update("offline", &data.ResponseData{}) // should become offline
nodes.Update("online", &data.ResponseData{}) // should stay online
expire := nodes.List["expire"]
expire.Lastseen = expire.Lastseen.Add((-7 * time.Hour * 24) - time.Minute)
2016-10-08 11:52:11 +02:00
offline := nodes.List["offline"]
offline.Lastseen = offline.Lastseen.Add((-7 * time.Hour * 24) + time.Minute)
2016-10-08 11:52:11 +02:00
nodes.expire()
// one expired?
assert.Len(nodes.List, 2)
2016-10-08 11:52:11 +02:00
assert.Nil(nodes.List["expire"])
// one offline?
assert.NotNil(nodes.List["offline"])
assert.False(nodes.List["offline"].Online)
2016-10-08 11:52:11 +02:00
// one online?
assert.NotNil(nodes.List["online"])
assert.True(nodes.List["online"].Online)
2016-10-08 11:52:11 +02:00
}
2016-03-20 18:30:44 +01:00
func TestLoadAndSave(t *testing.T) {
assert := assert.New(t)
config := &NodesConfig{}
// not autoload without StatePath
NewNodes(config)
2016-03-20 18:30:44 +01:00
2019-05-19 10:22:56 +02:00
// Test unmarshalable
config.StatePath = "testdata/nodes-broken.json"
2016-11-20 18:45:18 +01:00
nodes := NewNodes(config)
// Test unopen able
config.StatePath = "/root/nodes.json"
nodes.load()
// works ;)
config.StatePath = "testdata/nodes.json"
2016-03-20 18:30:44 +01:00
nodes.load()
tmpfile, _ := ioutil.TempFile("/tmp", "nodes")
config.StatePath = tmpfile.Name()
nodes.save()
2016-03-20 18:30:44 +01:00
os.Remove(tmpfile.Name())
2019-01-17 13:26:16 +01:00
assert.Panics(func() {
2019-05-19 10:22:56 +02:00
SaveJSON(nodes, "/proc/a")
// "open /proc/a.tmp: permission denied",
})
tmpfile, _ = ioutil.TempFile("/tmp", "nodes")
2019-01-17 13:26:16 +01:00
assert.Panics(func() {
SaveJSON(tmpfile.Name, tmpfile.Name())
2019-01-17 13:26:16 +01:00
// "json: unsupported type: func() string",
})
os.Remove(tmpfile.Name())
//TODO how to test easy a failing renaming
assert.Len(nodes.List, 2)
2016-03-20 18:30:44 +01:00
}
2016-03-21 12:26:08 +01:00
func TestUpdateNodes(t *testing.T) {
assert := assert.New(t)
nodes := &Nodes{
List: make(map[string]*Node),
ifaceToNodeID: make(map[string]string),
}
assert.Len(nodes.List, 0)
2016-03-21 12:26:08 +01:00
res := &data.ResponseData{
Neighbours: &data.Neighbours{},
Statistics: &data.Statistics{
Wireless: data.WirelessStatistics{
&data.WirelessAirtime{},
},
},
Nodeinfo: &data.Nodeinfo{},
2016-03-21 12:26:08 +01:00
}
nodes.Update("abcdef012345", res)
// Update wireless statistics by running SetUtilization
nodes.Update("abcdef012345", res)
assert.Len(nodes.List, 1)
2016-03-21 12:26:08 +01:00
}
func TestSelectNodes(t *testing.T) {
assert := assert.New(t)
config := &NodesConfig{}
config.StatePath = "testdata/nodes.json"
nodes := NewNodes(config)
selectedNodes := nodes.Select(func(n *Node) bool {
return true
})
assert.Len(selectedNodes, 2)
selectedNodes = nodes.Select(func(n *Node) bool {
return false
})
assert.Len(selectedNodes, 0)
selectedNodes = nodes.Select(func(n *Node) bool {
return n.Nodeinfo.NodeID == "f4f26dd7a30a"
})
assert.Len(selectedNodes, 1)
time := jsontime.Time{}
2022-03-28 03:56:00 +02:00
assert.NoError(time.UnmarshalJSON([]byte("\"2017-03-10T12:12:01\"")))
assert.Equal(time, selectedNodes[0].Firstseen)
}
func TestAddNode(t *testing.T) {
assert := assert.New(t)
nodes := NewNodes(&NodesConfig{})
nodes.AddNode(&Node{})
assert.Len(nodes.List, 0)
nodes.AddNode(&Node{Nodeinfo: &data.Nodeinfo{}})
assert.Len(nodes.List, 0)
nodes.AddNode(&Node{Nodeinfo: &data.Nodeinfo{NodeID: "blub"}})
assert.Len(nodes.List, 1)
}
func TestLinksNodes(t *testing.T) {
assert := assert.New(t)
nodes := &Nodes{
List: make(map[string]*Node),
ifaceToNodeID: make(map[string]string),
}
assert.Len(nodes.List, 0)
2019-05-19 10:22:56 +02:00
nodes.Update("f4f26dd7a300", &data.ResponseData{
Nodeinfo: &data.Nodeinfo{
NodeID: "f4f26dd7a300",
Network: data.Network{
Mac: "f4:f2:6d:d7:a3:00",
},
},
})
nodes.Update("f4f26dd7a30a", &data.ResponseData{
Nodeinfo: &data.Nodeinfo{
NodeID: "f4f26dd7a30a",
Network: data.Network{
Mac: "f4:f2:6d:d7:a3:0a",
},
},
2019-05-19 10:22:56 +02:00
Neighbours: &data.Neighbours{
NodeID: "f4f26dd7a30a",
Babel: map[string]data.BabelNeighbours{
"vx_mesh_lan": {
LinkLocalAddress: "fe80::2",
Neighbours: map[string]data.BabelLink{
"fe80::1337": {
Cost: 26214,
},
},
},
},
},
})
nodes.Update("f4f26dd7a30b", &data.ResponseData{
Nodeinfo: &data.Nodeinfo{
NodeID: "f4f26dd7a30b",
2019-05-19 10:22:56 +02:00
Network: data.Network{
Mesh: map[string]*data.NetworkInterface{
"babel": {
Interfaces: struct {
Wireless []string `json:"wireless,omitempty"`
Other []string `json:"other,omitempty"`
Tunnel []string `json:"tunnel,omitempty"`
}{
Other: []string{"fe80::1337"},
},
},
},
},
},
Neighbours: &data.Neighbours{
NodeID: "f4f26dd7a30b",
Batadv: map[string]data.BatadvNeighbours{
2018-01-13 16:40:23 +01:00
"f4:f2:6d:d7:a3:0b": {
Neighbours: map[string]data.BatmanLink{
2018-01-13 16:40:23 +01:00
"f4:f2:6d:d7:a3:0a": {
Tq: 204, Lastseen: 0.42,
},
},
},
},
},
})
2019-05-19 10:22:56 +02:00
// no neighbours nodeid
node := nodes.List["f4f26dd7a300"]
assert.NotNil(node)
links := nodes.NodeLinks(node)
assert.Len(links, 0)
2019-05-19 10:22:56 +02:00
// babel link
node = nodes.List["f4f26dd7a30a"]
assert.NotNil(node)
links = nodes.NodeLinks(node)
assert.Len(links, 1)
link := links[0]
2019-05-19 10:22:56 +02:00
assert.Equal("f4f26dd7a30a", link.SourceID)
assert.Equal("fe80::2", link.SourceAddress)
assert.Equal("f4f26dd7a30b", link.TargetID)
assert.Equal("fe80::1337", link.TargetAddress)
assert.Equal(float32(0.6), link.TQ)
// batman link
node = nodes.List["f4f26dd7a30b"]
assert.NotNil(node)
links = nodes.NodeLinks(node)
assert.Len(links, 1)
link = links[0]
assert.Equal("f4f26dd7a30b", link.SourceID)
assert.Equal("f4:f2:6d:d7:a3:0b", link.SourceAddress)
assert.Equal("f4f26dd7a30a", link.TargetID)
assert.Equal("f4:f2:6d:d7:a3:0a", link.TargetAddress)
assert.Equal(float32(0.8), link.TQ)
nodeid := nodes.GetNodeIDbyAddress("f4:f2:6d:d7:a3:0a")
assert.Equal("f4f26dd7a30a", nodeid)
}