Events, generalizar para cualquier tipo de map

Permitirmos que se agrupen eventos siempre que el tipo de dato
almacenado en Metadata.Key sea un map.

Author: adrianlzt

gremlin/traversal/events.go

@@ -1,6 +1,7 @@
 package traversal
 
 import (
+	"fmt"
 	"reflect"
 	"time"
 
@@ -18,7 +19,7 @@ type EventsTraversalExtension struct {
 // EventsGremlinTraversalStep step aggregates events from different revisions of the nodes into a new metadata key.
 // This step should be used with a presistant backend, so it can access previous revisions of the nodes.
 // To use this step we should select a metadata key (first parameter), where the events will be read from.
-// Inside this Metadata.Key events should have the format map[string]interface{}.
+// Inside this Metadata.Key events should have the format map[interface{}]interface{} (could be a type based on that).
 // The second parameter is the metadata key where all the events will be aggregated.
 // The aggregation will with the format: map[string][]interface{}.
 // All events with the same key in the map will be joined in an slice.
@@ -202,21 +203,40 @@ func (s *EventsGremlinTraversalStep) InterfaceEvents(tv *traversal.GraphTraversa
 // mergeEvents return the merge of node.Key events with the ones already stored in nodeEvents
 // Eg.:
 //   node:       Metadata.key: {"a":{x}, "b":{y}}
-//   nodeEvents:               {"a":{z}}
+//   nodeEvents:               {"a":[{z}]}
 //   return:     Metadata.key: {"a":[{x},{z}], "b":[{y}]}
 //
-// Ignore if Metadata.key has an invalid format.
+// Ignore if Metadata.key has an invalid format (not a map).
+// Reflect is used to be able to access map's defined in different types.
+// Event aggregation data type should be map[string]interface{} to be able to be encoded with JSON
 func mergeEvents(node *graph.Node, key string, nodeEvents map[string][]interface{}) map[string][]interface{} {
 	if nodeEvents == nil {
 		nodeEvents = map[string][]interface{}{}
 	}
 
 	n1EventsIface, n1Err := node.GetField(key)
+
 	if n1Err == nil {
-		// Ignore Metadata.key values with not a valid format
-		n1Events, _ := n1EventsIface.(map[string]interface{})
+		// Ignore Metadata.key values which are not a map
+		n1EventsValue := reflect.ValueOf(n1EventsIface)
+
+		// If the metadata value is a pointer, resolve it
+		if n1EventsValue.Kind() == reflect.Ptr {
+			n1EventsValue = n1EventsValue.Elem()
+		}
+
+		// Events step only accepts a map as data origin
+		if n1EventsValue.Kind() != reflect.Map {
+			logging.GetLogger().Errorf("Invalid type for events, expecting a map, but it is %v", n1EventsValue.Kind())
+			return nodeEvents
+		}
+
+		iter := n1EventsValue.MapRange()
 	NODE_EVENTS:
-		for k, v := range n1Events {
+		for iter.Next() {
+			k := fmt.Sprintf("%v", iter.Key().Interface())
+			v := iter.Value().Interface()
+
 			// Do not append if the same event already exists
 			for _, storedEvent := range nodeEvents[k] {
 				if reflect.DeepEqual(storedEvent, v) {

gremlin/traversal/events_test.go

@@ -45,15 +45,36 @@ func TestMergeEventsNilNodeEvents(t *testing.T) {
 	key := "Events"
 
 	metadataNode1 := graph.Metadata{key: map[string]interface{}{
-		"abc": map[string]string{"descr": "foo"},
+		"abc": map[interface{}]string{"descr": "foo"},
 	}}
 	node := CreateNode("nodeA", metadataNode1, graph.TimeUTC(), 1)
 
 	nodeEventsAgg := mergeEvents(node, key, nil)
 
-	expected := map[string][]interface{}{
+	expected := map[interface{}][]interface{}{
 		"abc": {
-			map[string]string{"descr": "foo"},
+			map[interface{}]string{"descr": "foo"},
+		},
+	}
+
+	assert.Equal(t, expected, nodeEventsAgg)
+}
+
+func TestMergeEventsPointerValue(t *testing.T) {
+	key := "Events"
+
+	value := map[string]interface{}{
+		"abc": map[interface{}]string{"descr": "foo"},
+	}
+
+	metadataNode1 := graph.Metadata{key: &value}
+	node := CreateNode("nodeA", metadataNode1, graph.TimeUTC(), 1)
+
+	nodeEventsAgg := mergeEvents(node, key, nil)
+
+	expected := map[interface{}][]interface{}{
+		"abc": {
+			map[interface{}]string{"descr": "foo"},
 		},
 	}
 
@@ -64,19 +85,19 @@ func TestMergeEvents(t *testing.T) {
 	tests := []struct {
 		name        string
 		nodesEvents []interface{}
-		expected    map[string][]interface{}
+		expected    map[interface{}][]interface{}
 	}{
 		{
 			name:     "no nodes",
-			expected: map[string][]interface{}{},
+			expected: map[interface{}][]interface{}{},
 		},
 		{
 			name: "one node",
 			nodesEvents: []interface{}{
 				map[string]interface{}{
 					"abc": map[string]string{"descr": "foo"},
 				}},
-			expected: map[string][]interface{}{
+			expected: map[interface{}][]interface{}{
 				"abc": {
 					map[string]string{"descr": "foo"},
 				},
@@ -91,7 +112,7 @@ func TestMergeEvents(t *testing.T) {
 				map[string]interface{}{
 					"xyz": map[string]string{"descr": "bar"},
 				}},
-			expected: map[string][]interface{}{
+			expected: map[interface{}][]interface{}{
 				"abc": {
 					map[string]string{"descr": "foo"},
 				},
@@ -109,7 +130,7 @@ func TestMergeEvents(t *testing.T) {
 				map[string]interface{}{
 					"abc": map[string]string{"descr": "bar"},
 				}},
-			expected: map[string][]interface{}{
+			expected: map[interface{}][]interface{}{
 				"abc": {
 					map[string]string{"descr": "foo"},
 					map[string]string{"descr": "bar"},
@@ -126,7 +147,7 @@ func TestMergeEvents(t *testing.T) {
 					"abc": map[string]string{"descr": "foo"},
 					"xxx": map[string]string{"descr": "bar"},
 				}},
-			expected: map[string][]interface{}{
+			expected: map[interface{}][]interface{}{
 				"abc": {
 					map[string]string{"descr": "foo"},
 				},
@@ -141,7 +162,7 @@ func TestMergeEvents(t *testing.T) {
 
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
-			nodeEventsAgg := map[string][]interface{}{}
+			nodeEventsAgg := map[interface{}][]interface{}{}
 
 			for _, nodeEvents := range test.nodesEvents {
 				metadataNode1 := graph.Metadata{key: nodeEvents}