func TestMapRender1(t *testing.T) {
// 1. Check when we return false, the node gets filtered out
mapper := render.Map{
MapFunc: func(nodes render.RenderableNode, _ report.Networks) render.RenderableNodes {
return render.RenderableNodes{}
},
Renderer: mockRenderer{RenderableNodes: render.RenderableNodes{
"foo": render.NewRenderableNode("foo"),
}},
}
want := render.RenderableNodes{}
have := mapper.Render(report.MakeReport())
if !reflect.DeepEqual(want, have) {
t.Errorf("want %+v, have %+v", want, have)
}
}
func TestMapRender2(t *testing.T) {
// 2. Check we can remap two nodes into one
mapper := render.Map{
MapFunc: func(nodes render.RenderableNode) (render.RenderableNode, bool) {
return render.RenderableNode{ID: "bar"}, true
},
Renderer: mockRenderer{RenderableNodes: render.RenderableNodes{
"foo": {ID: "foo"},
"baz": {ID: "baz"},
}},
}
want := render.RenderableNodes{
"bar": render.RenderableNode{ID: "bar"},
}
have := mapper.Render(report.MakeReport())
if !reflect.DeepEqual(want, have) {
t.Errorf("want %+v, have %+v", want, have)
}
}
func TestMapRender2(t *testing.T) {
// 2. Check we can remap two nodes into one
mapper := render.Map{
MapFunc: func(nodes render.RenderableNode) render.RenderableNodes {
return render.RenderableNodes{"bar": render.RenderableNode{ID: "bar"}}
},
Renderer: mockRenderer{RenderableNodes: render.RenderableNodes{
"foo": {ID: "foo"},
"baz": {ID: "baz"},
}},
}
want := sterilize(render.RenderableNodes{
"bar": render.RenderableNode{ID: "bar"},
}, false)
have := mapper.Render(report.MakeReport())
if !reflect.DeepEqual(want, have) {
t.Error(test.Diff(want, have))
}
}
func TestMapEdge(t *testing.T) {
selector := func(_ report.Report) report.Topology {
return report.Topology{
NodeMetadatas: report.NodeMetadatas{
"foo": report.NewNodeMetadata(map[string]string{"id": "foo"}),
"bar": report.NewNodeMetadata(map[string]string{"id": "bar"}),
},
Adjacency: report.Adjacency{
">foo": report.MakeIDList("bar"),
">bar": report.MakeIDList("foo"),
},
EdgeMetadatas: report.EdgeMetadatas{
"foo|bar": report.EdgeMetadata{WithBytes: true, BytesIngress: 1, BytesEgress: 2},
"bar|foo": report.EdgeMetadata{WithBytes: true, BytesIngress: 3, BytesEgress: 4},
},
}
}
identity := func(nmd report.NodeMetadata) (render.RenderableNode, bool) {
return render.NewRenderableNode(nmd.Metadata["id"], "", "", "", nmd), true
}
mapper := render.Map{
MapFunc: func(nodes render.RenderableNode) (render.RenderableNode, bool) {
return render.RenderableNode{ID: "_" + nodes.ID}, true
},
Renderer: render.LeafMap{
Selector: selector,
Mapper: identity,
Pseudo: nil,
},
}
want := render.AggregateMetadata{
render.KeyBytesIngress: 1,
render.KeyBytesEgress: 2,
}
have := mapper.AggregateMetadata(report.MakeReport(), "_foo", "_bar")
if !reflect.DeepEqual(want, have) {
t.Errorf("want %+v, have %+v", want, have)
}
}
func TestMapRender3(t *testing.T) {
// 3. Check we can remap adjacencies
mapper := render.Map{
MapFunc: func(nodes render.RenderableNode) (render.RenderableNode, bool) {
return render.RenderableNode{ID: "_" + nodes.ID}, true
},
Renderer: mockRenderer{RenderableNodes: render.RenderableNodes{
"foo": {ID: "foo", Adjacency: report.MakeIDList("baz")},
"baz": {ID: "baz", Adjacency: report.MakeIDList("foo")},
}},
}
want := render.RenderableNodes{
"_foo": {ID: "_foo", Adjacency: report.MakeIDList("_baz")},
"_baz": {ID: "_baz", Adjacency: report.MakeIDList("_foo")},
}
have := mapper.Render(report.MakeReport())
if !reflect.DeepEqual(want, have) {
t.Errorf("want %+v, have %+v", want, have)
}
}
func TestMapEdge(t *testing.T) {
selector := func(_ report.Report) report.Topology {
return report.Topology{
NodeMetadatas: report.NodeMetadatas{
"foo": report.MakeNodeMetadataWith(map[string]string{"id": "foo"}),
"bar": report.MakeNodeMetadataWith(map[string]string{"id": "bar"}),
},
Adjacency: report.Adjacency{
">foo": report.MakeIDList("bar"),
">bar": report.MakeIDList("foo"),
},
EdgeMetadatas: report.EdgeMetadatas{
"foo|bar": report.EdgeMetadata{EgressPacketCount: newu64(1), EgressByteCount: newu64(2)},
"bar|foo": report.EdgeMetadata{EgressPacketCount: newu64(3), EgressByteCount: newu64(4)},
},
}
}
identity := func(nmd report.NodeMetadata) render.RenderableNodes {
return render.RenderableNodes{nmd.Metadata["id"]: render.NewRenderableNode(nmd.Metadata["id"], "", "", "", nmd)}
}
mapper := render.Map{
MapFunc: func(nodes render.RenderableNode) render.RenderableNodes {
id := "_" + nodes.ID
return render.RenderableNodes{id: render.RenderableNode{ID: id}}
},
Renderer: render.LeafMap{
Selector: selector,
Mapper: identity,
Pseudo: nil,
},
}
if want, have := (report.EdgeMetadata{
EgressPacketCount: newu64(1),
EgressByteCount: newu64(2),
}), mapper.EdgeMetadata(report.MakeReport(), "_foo", "_bar"); !reflect.DeepEqual(want, have) {
t.Error(test.Diff(want, have))
}
}
func TestMapRender3(t *testing.T) {
// 3. Check we can remap adjacencies
mapper := render.Map{
MapFunc: func(nodes render.RenderableNode, _ report.Networks) render.RenderableNodes {
id := "_" + nodes.ID
return render.RenderableNodes{id: render.NewRenderableNode(id)}
},
Renderer: mockRenderer{RenderableNodes: render.RenderableNodes{
"foo": render.NewRenderableNode("foo").WithNode(report.MakeNode().WithAdjacent("baz")),
"baz": render.NewRenderableNode("baz").WithNode(report.MakeNode().WithAdjacent("foo")),
}},
}
want := render.RenderableNodes{
"_foo": render.NewRenderableNode("_foo").WithNode(report.MakeNode().WithAdjacent("_baz")),
"_baz": render.NewRenderableNode("_baz").WithNode(report.MakeNode().WithAdjacent("_foo")),
}
have := mapper.Render(report.MakeReport())
if !reflect.DeepEqual(want, have) {
t.Error(test.Diff(want, have))
}
}
func TestMapRender2(t *testing.T) {
// 2. Check we can remap two nodes into one
mapper := render.Map{
MapFunc: func(nodes render.RenderableNode, _ report.Networks) render.RenderableNodes {
return render.RenderableNodes{
"bar": render.NewRenderableNode("bar"),
}
},
Renderer: mockRenderer{RenderableNodes: render.RenderableNodes{
"foo": render.NewRenderableNode("foo"),
"baz": render.NewRenderableNode("baz"),
}},
}
want := render.RenderableNodes{
"bar": render.NewRenderableNode("bar"),
}
have := mapper.Render(report.MakeReport())
if !reflect.DeepEqual(want, have) {
t.Error(test.Diff(want, have))
}
}
func TestMapEdge(t *testing.T) {
selector := render.TopologySelector(func(_ report.Report) render.RenderableNodes {
return render.MakeRenderableNodes(report.Topology{
Nodes: report.Nodes{
"foo": report.MakeNode().WithMetadata(map[string]string{
"id": "foo",
}).WithEdge("bar", report.EdgeMetadata{
EgressPacketCount: newu64(1),
EgressByteCount: newu64(2),
}),
"bar": report.MakeNode().WithMetadata(map[string]string{
"id": "bar",
}).WithEdge("foo", report.EdgeMetadata{
EgressPacketCount: newu64(3),
EgressByteCount: newu64(4),
}),
},
})
})
mapper := render.Map{
MapFunc: func(node render.RenderableNode, _ report.Networks) render.RenderableNodes {
id := "_" + node.ID
return render.RenderableNodes{id: render.NewDerivedNode(id, node)}
},
Renderer: selector,
}
have := mapper.Render(report.MakeReport()).Prune()
want := (render.RenderableNodes{
"_foo": {
ID: "_foo",
Origins: report.MakeIDList("foo"),
Node: report.MakeNode().WithAdjacent("_bar"),
EdgeMetadata: report.EdgeMetadata{
EgressPacketCount: newu64(1),
EgressByteCount: newu64(2),
IngressPacketCount: newu64(3),
IngressByteCount: newu64(4),
},
},
"_bar": {
ID: "_bar",
Origins: report.MakeIDList("bar"),
Node: report.MakeNode().WithAdjacent("_foo"),
EdgeMetadata: report.EdgeMetadata{
EgressPacketCount: newu64(3),
EgressByteCount: newu64(4),
IngressPacketCount: newu64(1),
IngressByteCount: newu64(2),
},
},
}).Prune()
if !reflect.DeepEqual(want, have) {
t.Error(test.Diff(want, have))
}
if want, have := (report.EdgeMetadata{
EgressPacketCount: newu64(1),
EgressByteCount: newu64(2),
}), mapper.EdgeMetadata(report.MakeReport(), "_foo", "_bar"); !reflect.DeepEqual(want, have) {
t.Error(test.Diff(want, have))
}
}