Rename Map -> LeafMap, introduce Map (with tests)

render/render_test.go

@@ -55,6 +55,109 @@ func TestReduceEdge(t *testing.T) {
 	}
 }
 
+func TestMapRender(t *testing.T) {
+	// 1. Check when we return false, the node gets filtered out
+	{
+		mapper := render.Map{
+			MapFunc: func(nodes render.RenderableNode) (render.RenderableNode, bool) {
+				return render.RenderableNode{}, false
+			},
+			Renderer: mockRenderer{RenderableNodes: render.RenderableNodes{
+				"foo": {ID: "foo"},
+			}},
+		}
+		want := render.RenderableNodes{}
+		have := mapper.Render(report.MakeReport())
+		if !reflect.DeepEqual(want, have) {
+			t.Errorf("want %+v, have %+v", want, have)
+		}
+	}
+
+	// 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)
+		}
+	}
+
+	// 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.NodeMetadata{"id": "foo"},
+				"bar": report.NodeMetadata{"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["id"], "", "", ""), 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 := report.AggregateMetadata{
+		report.KeyBytesIngress: 1,
+		report.KeyBytesEgress:  2,
+	}
+	have := mapper.AggregateMetadata(report.MakeReport(), "_foo", "_bar")
+	if !reflect.DeepEqual(want, have) {
+		t.Errorf("want %+v, have %+v", want, have)
+	}
+}
+
 var (
 	clientHostID  = "client.hostname.com"
 	serverHostID  = "server.hostname.com"
@@ -287,7 +390,11 @@ func TestRenderByEndpointPID(t *testing.T) {
 			Metadata:   report.AggregateMetadata{},
 		},
 	}
-	have := render.Topology(rpt.Endpoint, render.ProcessPID, render.GenericPseudoNode)
+	have := render.LeafMap{
+		Selector: report.SelectEndpoint,
+		Mapper: render.ProcessPID,
+		Pseudo: render.GenericPseudoNode,
+	}.Render(rpt)
 	if !reflect.DeepEqual(want, have) {
 		t.Error("\n" + diff(want, have))
 	}
@@ -341,7 +448,11 @@ func TestRenderByEndpointPIDGrouped(t *testing.T) {
 			Metadata:   report.AggregateMetadata{},
 		},
 	}
-	have := render.Topology(rpt.Endpoint, render.ProcessName, render.GenericGroupedPseudoNode)
+	have := render.LeafMap{
+		Selector: report.SelectEndpoint,
+		Mapper: render.ProcessName,
+		Pseudo: render.GenericGroupedPseudoNode,
+	}.Render(rpt)
 	if !reflect.DeepEqual(want, have) {
 		t.Error("\n" + diff(want, have))
 	}
@@ -396,7 +507,11 @@ func TestRenderByNetworkHostname(t *testing.T) {
 			Metadata:   report.AggregateMetadata{},
 		},
 	}
-	have := render.Topology(rpt.Address, render.NetworkHostname, render.GenericPseudoNode)
+	have := render.LeafMap{
+		Selector: report.SelectAddress,
+		Mapper: render.NetworkHostname,
+		Pseudo: render.GenericPseudoNode,
+	}.Render(rpt)
 	if !reflect.DeepEqual(want, have) {
 		t.Error("\n" + diff(want, have))
 	}