From ed7d9d7dc3940c227664ce2f4bbcc533647f5b8b Mon Sep 17 00:00:00 2001 From: Quang Nguyen Date: Fri, 15 Mar 2024 12:30:34 -0400 Subject: [PATCH] chore: remove unused store pkg (#48) removing this package since i don't see it being used anywhere. --- pkg/store/dagger.go | 525 --------- pkg/store/dagger_test.go | 2169 -------------------------------------- pkg/store/graph.go | 48 - 3 files changed, 2742 deletions(-) delete mode 100644 pkg/store/dagger.go delete mode 100644 pkg/store/dagger_test.go delete mode 100644 pkg/store/graph.go diff --git a/pkg/store/dagger.go b/pkg/store/dagger.go deleted file mode 100644 index 2ce4657a53..0000000000 --- a/pkg/store/dagger.go +++ /dev/null @@ -1,525 +0,0 @@ -// Copyright (c) Microsoft Corporation. -// Licensed under the MIT license. -package store - -import ( - "errors" - "strings" - - "github.com/autom8ter/dagger" -) - -const ( - NodeXIDDelimiter = "." - EdgeXIDDelimiter = "->" - - NodeXTypePod = "pod" - NodeXTypeSvc = "service" - // XXX: Not covered until we know how to represent this - NodeXTypeExt = "ext" - - EdgeXTypeConnection = "connection" - - ReservedAttributeNodeType = "node_type" - ReservedAttributeEdgeType = "edge_type" - ReservedAttributeName = "name" - ReservedAttributeNamespace = "namespace" - ReservedAttributeXID = "xid" -) - -type Dagger struct { - // logger *log.ZapLogger - graph *dagger.Graph -} - -// func NewDaggerStore(logger *log.ZapLogger) *Dagger { -func NewDaggerStore() *Dagger { - d := dagger.NewGraph() - graph := &Dagger{ - // logger: logger, - graph: d, - } - - return graph -} - -func (d *Dagger) AddNode(node Node) { - xtype := string(NodeXTypeFromString(node.objType)) - - if node.attributes == nil { - node.attributes = make(map[string]interface{}) - } - - node.attributes[ReservedAttributeNodeType] = xtype - node.attributes[ReservedAttributeName] = node.name - node.attributes[ReservedAttributeNamespace] = node.namespace - - _ = d.graph.SetNode(dagger.Path{ - XID: generateNodeXID(node.name, node.namespace), - XType: xtype, - }, node.attributes) -} - -func (d *Dagger) DelNode(node Node) { - d.graph.DelNode(dagger.Path{ - XID: generateNodeXID(node.name, node.namespace), - XType: NodeXTypeFromString(node.objType), - }) -} - -func (d *Dagger) GetNodeAttributes(node Node) (map[string]interface{}, error) { - n, ok := d.graph.GetNode(dagger.Path{ - XID: generateNodeXID(node.name, node.namespace), - XType: NodeXTypeFromString(node.objType), - }) - if !ok { - return nil, errors.New("node not found") - } - - return n.Attributes, nil -} - -func (d *Dagger) GetNodeAttribute(node Node, key string) (interface{}, error) { - n, ok := d.graph.GetNode(dagger.Path{ - XID: generateNodeXID(node.name, node.namespace), - XType: NodeXTypeFromString(node.objType), - }) - if !ok { - return nil, errors.New("node not found") - } - - v, ok := n.Attributes[key] - if !ok { - return nil, errors.New("attribute not found") - } - return v, nil -} - -func (d *Dagger) SetNodeAttributes(node Node, attributes map[string]interface{}) (map[string]interface{}, error) { - // TODO: Prevent overwriting reserved keys - n, ok := d.graph.GetNode(dagger.Path{ - XID: generateNodeXID(node.name, node.namespace), - XType: NodeXTypeFromString(node.objType), - }) - if !ok { - return nil, errors.New("node not found") - } - - for k, v := range attributes { - n.Attributes[k] = v - } - - _ = d.graph.SetNode(n.Path, n.Attributes) - - return n.Attributes, nil -} - -func (d *Dagger) SetNodeAttribute(node Node, key string, value interface{}) (map[string]interface{}, error) { - // TODO: Prevent overwriting reserved keys - n, ok := d.graph.GetNode(dagger.Path{ - XID: generateNodeXID(node.name, node.namespace), - XType: NodeXTypeFromString(node.objType), - }) - if !ok { - return nil, errors.New("node not found") - } - - if value == nil { - return nil, errors.New("value cannot be nil") - } - - n.Attributes[key] = value - - _ = d.graph.SetNode(n.Path, n.Attributes) - - return n.Attributes, nil -} - -func (d *Dagger) DelNodeAttribute(node Node, key string) (map[string]interface{}, error) { - n, ok := d.graph.GetNode(dagger.Path{ - XID: generateNodeXID(node.name, node.namespace), - XType: NodeXTypeFromString(node.objType), - }) - if !ok { - return nil, errors.New("node not found") - } - - delete(n.Attributes, key) - - _ = d.graph.SetNode(n.Path, n.Attributes) - - return n.Attributes, nil -} - -func (d *Dagger) AddEdge(edge Edge) error { - if edge.attributes == nil { - edge.attributes = make(map[string]interface{}) - } - - edge.attributes[ReservedAttributeEdgeType] = EdgeXTypeConnection - - fromXID := generateNodeXID(edge.from.name, edge.from.namespace) - edge.attributes["from_"+ReservedAttributeNodeType] = NodeXTypeFromString(edge.from.objType) - edge.attributes["from_"+ReservedAttributeName] = edge.from.name - edge.attributes["from_"+ReservedAttributeNamespace] = edge.from.namespace - edge.attributes["from_"+ReservedAttributeXID] = fromXID - - toXID := generateNodeXID(edge.to.name, edge.to.namespace) - edge.attributes["to_"+ReservedAttributeNodeType] = NodeXTypeFromString(edge.to.objType) - edge.attributes["to_"+ReservedAttributeName] = edge.to.name - edge.attributes["to_"+ReservedAttributeNamespace] = edge.to.namespace - edge.attributes["to_"+ReservedAttributeXID] = toXID - - if _, err := d.graph.SetEdge(dagger.Path{ - XID: fromXID, - XType: NodeXTypeFromString(edge.from.objType), - }, dagger.Path{ - XID: toXID, - XType: NodeXTypeFromString(edge.to.objType), - }, dagger.Node{ - Path: dagger.Path{ - XID: generateEdgeXID(fromXID, toXID), - XType: string(EdgeXTypeConnection), - }, - Attributes: edge.attributes, - }); err != nil { - return err - } - return nil -} - -func (d *Dagger) DelEdge(edge Edge) { - fromXID := generateNodeXID(edge.from.name, edge.from.namespace) - toXID := generateNodeXID(edge.to.name, edge.to.namespace) - - d.graph.DelEdge(dagger.Path{ - XID: generateEdgeXID(fromXID, toXID), - XType: string(EdgeXTypeConnection), - }) -} - -func (d *Dagger) GetEdgeNodes(edge Edge) (Node, Node, error) { - toXID := generateNodeXID(edge.to.name, edge.to.namespace) - fromXID := generateNodeXID(edge.from.name, edge.from.namespace) - - e, ok := d.graph.GetEdge(dagger.Path{ - XID: generateEdgeXID(fromXID, toXID), - XType: string(EdgeXTypeConnection), - }) - if !ok { - return Node{}, Node{}, errors.New("edge not found") - } - - from, ok := d.graph.GetNode(e.From) - if !ok { - return Node{}, Node{}, errors.New("from node not found") - } - - to, ok := d.graph.GetNode(e.To) - if !ok { - return Node{}, Node{}, errors.New("to node not found") - } - - fromNode := Node{ - objType: edge.from.objType, - name: edge.from.name, - namespace: edge.from.namespace, - attributes: from.Attributes, - } - toNode := Node{ - objType: edge.to.objType, - name: edge.to.name, - namespace: edge.to.namespace, - attributes: to.Attributes, - } - return fromNode, toNode, nil -} - -func (d *Dagger) GetEdgeAttributes(edge Edge) (map[string]interface{}, error) { - toXID := generateNodeXID(edge.to.name, edge.to.namespace) - fromXID := generateNodeXID(edge.from.name, edge.from.namespace) - - e, ok := d.graph.GetEdge(dagger.Path{ - XID: generateEdgeXID(fromXID, toXID), - XType: string(EdgeXTypeConnection), - }) - if !ok { - return nil, errors.New("edge not found") - } - return e.Attributes, nil -} - -func (d *Dagger) GetEdgeAttribute(edge Edge, key string) (interface{}, error) { - toXID := generateNodeXID(edge.to.name, edge.to.namespace) - fromXID := generateNodeXID(edge.from.name, edge.from.namespace) - - e, ok := d.graph.GetEdge(dagger.Path{ - XID: generateEdgeXID(fromXID, toXID), - XType: string(EdgeXTypeConnection), - }) - if !ok { - return nil, errors.New("edge not found") - } - - v, ok := e.Attributes[key] - if ok { - return v, nil - } - - return nil, errors.New("attribute not found") -} - -func (d *Dagger) SetEdgeAttributes(edge Edge, attributes map[string]interface{}) (map[string]interface{}, error) { - toXID := generateNodeXID(edge.to.name, edge.to.namespace) - fromXID := generateNodeXID(edge.from.name, edge.from.namespace) - - e, ok := d.graph.GetEdge(dagger.Path{ - XID: generateEdgeXID(fromXID, toXID), - XType: string(EdgeXTypeConnection), - }) - if !ok { - return nil, errors.New("edge not found") - } - - for k, v := range attributes { - e.Attributes[k] = v - } - - if _, err := d.graph.SetEdge( - dagger.Path{ - XID: fromXID, - XType: NodeXTypeFromString(edge.from.objType), - }, - dagger.Path{ - XID: toXID, - XType: NodeXTypeFromString(edge.to.objType), - }, - dagger.Node{ - Path: dagger.Path{ - XID: generateEdgeXID(fromXID, toXID), - XType: string(EdgeXTypeConnection), - }, - Attributes: e.Attributes, - }); err != nil { - return nil, err - } - - return e.Attributes, nil -} - -func (d *Dagger) SetEdgeAttribute(edge Edge, key string, value interface{}) (map[string]interface{}, error) { - toXID := generateNodeXID(edge.to.name, edge.to.namespace) - fromXID := generateNodeXID(edge.from.name, edge.from.namespace) - - e, ok := d.graph.GetEdge(dagger.Path{ - XID: generateEdgeXID(fromXID, toXID), - XType: string(EdgeXTypeConnection), - }) - if !ok { - return nil, errors.New("edge not found") - } - - e.Attributes[key] = value - - if _, err := d.graph.SetEdge( - dagger.Path{ - XID: fromXID, - XType: NodeXTypeFromString(edge.from.objType), - }, - dagger.Path{ - XID: toXID, - XType: NodeXTypeFromString(edge.to.objType), - }, - dagger.Node{ - Path: dagger.Path{ - XID: generateEdgeXID(fromXID, toXID), - XType: string(EdgeXTypeConnection), - }, - Attributes: e.Attributes, - }); err != nil { - return nil, err - } - - return e.Attributes, nil -} - -func (d *Dagger) DelEdgeAttribute(edge Edge, key string) (map[string]interface{}, error) { - toXID := generateNodeXID(edge.to.name, edge.to.namespace) - fromXID := generateNodeXID(edge.from.name, edge.from.namespace) - - e, ok := d.graph.GetEdge(dagger.Path{ - XID: generateEdgeXID(fromXID, toXID), - XType: string(EdgeXTypeConnection), - }) - if !ok { - return nil, errors.New("edge not found") - } - - delete(e.Attributes, key) - - if _, err := d.graph.SetEdge( - dagger.Path{ - XID: fromXID, - XType: NodeXTypeFromString(edge.from.objType), - }, - dagger.Path{ - XID: toXID, - XType: NodeXTypeFromString(edge.to.objType), - }, - dagger.Node{ - Path: dagger.Path{ - XID: generateEdgeXID(fromXID, toXID), - XType: string(EdgeXTypeConnection), - }, - Attributes: e.Attributes, - }); err != nil { - return nil, err - } - - return e.Attributes, nil -} - -func (d *Dagger) ListNodes() ([]Node, error) { - nodes := []Node{} - d.graph.RangeNodes(NodeXTypePod, func(n dagger.Node) bool { - name, namespace := nameNamespaceFromNodeXID(n.Path.XID) - nodes = append(nodes, Node{ - name: name, - namespace: namespace, - objType: NodeXTypeToString(n.Path.XType), - }) - return true - }) - - d.graph.RangeNodes(NodeXTypeSvc, func(n dagger.Node) bool { - name, namespace := nameNamespaceFromNodeXID(n.Path.XID) - nodes = append(nodes, Node{ - name: name, - namespace: namespace, - objType: NodeXTypeToString(n.Path.XType), - }) - return true - }) - - // XXX: Not covered until we know how to represent this - - // d.graph.RangeNodes(NodeXTypeExt, func(n dagger.Node) bool { - // name, namespace := nameNamespaceFromNodeXID(n.Path.XID) - // nodes = append(nodes, Node{ - // name: name, - // namespace: namespace, - // objType: NodeXTypeToString(n.Path.XType), - // }) - // return true - // }) - - return nodes, nil -} - -func (d *Dagger) ListNeighbors(node Node) ([]Node, error) { - fromXID := generateNodeXID(node.name, node.namespace) - - nodes := []Node{} - - d.graph.RangeEdgesFrom(EdgeXTypeConnection, dagger.Path{ - XID: fromXID, - XType: NodeXTypeFromString(node.objType), - }, func(e dagger.Edge) bool { - node, _ := d.graph.GetNode(e.To) - name, namespace := nameNamespaceFromNodeXID(node.Path.XID) - nodes = append(nodes, Node{ - name: name, - namespace: namespace, - objType: NodeXTypeToString(node.Path.XType), - }) - return true - }) - - return nodes, nil -} - -func (d *Dagger) ListOutboundEdges(node Node) ([]Edge, error) { - fromXID := generateNodeXID(node.name, node.namespace) - - edges := []Edge{} - - d.graph.RangeEdgesFrom(EdgeXTypeConnection, dagger.Path{ - XID: fromXID, - XType: NodeXTypeFromString(node.objType), - }, func(e dagger.Edge) bool { - toName, toNamespace := nameNamespaceFromNodeXID(e.To.XID) - edges = append(edges, Edge{ - from: node, - to: Node{ - name: toName, - namespace: toNamespace, - objType: NodeXTypeToString(e.To.XType), - }, - attributes: e.Attributes, - }) - return true - }) - - return edges, nil -} - -func (d *Dagger) ListInboundEdges(node Node) ([]Edge, error) { - toXID := generateNodeXID(node.name, node.namespace) - - edges := []Edge{} - - d.graph.RangeEdgesTo(EdgeXTypeConnection, dagger.Path{ - XID: toXID, - XType: NodeXTypeFromString(node.objType), - }, func(e dagger.Edge) bool { - fromName, fromNamespace := nameNamespaceFromNodeXID(e.From.XID) - edges = append(edges, Edge{ - to: node, - from: Node{ - name: fromName, - namespace: fromNamespace, - objType: NodeXTypeToString(e.From.XType), - }, - attributes: e.Attributes, - }) - return true - }) - - return edges, nil -} - -func generateNodeXID(name, namespace string) string { - return namespace + NodeXIDDelimiter + name -} - -func nameNamespaceFromNodeXID(nodeXID string) (string, string) { - parts := strings.Split(nodeXID, NodeXIDDelimiter) - return parts[1], parts[0] -} - -func NodeXTypeFromString(objType string) string { - switch strings.ToLower(objType) { - case "pod": - return NodeXTypePod - case "service": - return NodeXTypeSvc - default: - return NodeXTypeExt - } -} - -func NodeXTypeToString(xtype string) string { - switch strings.ToLower(xtype) { - case "pod": - return "pod" - case "service": - return "service" - default: - // XXX: Not covered until we know how to represent this - return NodeXTypeExt - } -} - -func generateEdgeXID(fromNodeXID, toNodeXID string) string { - return fromNodeXID + EdgeXIDDelimiter + toNodeXID -} diff --git a/pkg/store/dagger_test.go b/pkg/store/dagger_test.go deleted file mode 100644 index bed472cb90..0000000000 --- a/pkg/store/dagger_test.go +++ /dev/null @@ -1,2169 +0,0 @@ -// Copyright (c) Microsoft Corporation. -// Licensed under the MIT license. -//go:build unit -// +build unit - -package store - -import ( - "reflect" - "testing" -) - -func arrayEqualNode(x []Node, y []Node) bool { - for xItem := range x { - found := false - for yItem := range y { - if reflect.DeepEqual(xItem, yItem) { - found = true - break - } - } - - if !found { - return false - } - } - - return true -} - -func arrayEqualEdge(x []Edge, y []Edge) bool { - for xItem := range x { - found := false - for yItem := range y { - if reflect.DeepEqual(xItem, yItem) { - found = true - break - } - } - - if !found { - return false - } - } - - return true -} - -func TestDagger_GetNodeAttributes(t *testing.T) { - type fields struct { - d *Dagger - } - type args struct { - node Node - } - tests := []struct { - name string - fields fields - args args - want map[string]interface{} - wantErr bool - }{ - { - name: "additional attributes", - fields: fields{ - d: func() *Dagger { - d := NewDaggerStore() - d.AddNode(Node{ - name: "test-pod", - namespace: "test-namespace", - objType: "pod", - attributes: map[string]interface{}{ - "test-key": "test-value", - }, - }) - return d - }(), - }, - args: args{ - node: Node{ - objType: "pod", - name: "test-pod", - namespace: "test-namespace", - }, - }, - want: map[string]interface{}{ - ReservedAttributeNodeType: "pod", - ReservedAttributeName: "test-pod", - ReservedAttributeNamespace: "test-namespace", - "test-key": "test-value", - }, - wantErr: false, - }, - { - name: "node not found", - fields: fields{ - d: func() *Dagger { - d := NewDaggerStore() - return d - }(), - }, - args: args{ - node: Node{ - objType: "pod", - name: "test-pod", - namespace: "test-namespace", - }, - }, - want: nil, - wantErr: true, - }, - { - name: "nil attributes", - fields: fields{ - d: func() *Dagger { - d := NewDaggerStore() - d.AddNode(Node{ - name: "test-pod", - namespace: "test-namespace", - objType: "pod", - attributes: nil, - }) - return d - }(), - }, - args: args{ - node: Node{ - objType: "pod", - name: "test-pod", - namespace: "test-namespace", - }, - }, - want: map[string]interface{}{ - ReservedAttributeNodeType: "pod", - ReservedAttributeName: "test-pod", - ReservedAttributeNamespace: "test-namespace", - }, - wantErr: false, - }, - } - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - got, err := tt.fields.d.GetNodeAttributes(tt.args.node) - if (err != nil) != tt.wantErr { - t.Errorf("Dagger.GetNodeAttributes() error = %v, wantErr %v", err, tt.wantErr) - return - } - if !reflect.DeepEqual(got, tt.want) { - t.Errorf("Dagger.GetNodeAttributes() = %v, want %v", got, tt.want) - } - }) - } -} - -func TestDagger_GetNodeAttribute(t *testing.T) { - type fields struct { - d *Dagger - } - type args struct { - node Node - key string - } - tests := []struct { - name string - fields fields - args args - want interface{} - wantErr bool - }{ - { - name: "attribute exists", - fields: fields{ - d: func() *Dagger { - d := NewDaggerStore() - d.AddNode(Node{ - name: "test-pod", - namespace: "test-namespace", - objType: "pod", - attributes: map[string]interface{}{ - "test-key": "test-value", - }, - }) - return d - }(), - }, - args: args{ - node: Node{ - objType: "pod", - name: "test-pod", - namespace: "test-namespace", - }, - key: "test-key", - }, - want: "test-value", - wantErr: false, - }, - { - name: "attribute does not exist", - fields: fields{ - d: func() *Dagger { - d := NewDaggerStore() - d.AddNode(Node{ - name: "test-pod", - namespace: "test-namespace", - objType: "pod", - }) - return d - }(), - }, - args: args{ - node: Node{ - objType: "pod", - name: "test-pod", - namespace: "test-namespace", - }, - key: "test-key", - }, - want: nil, - wantErr: true, - }, - { - name: "node not found", - fields: fields{ - d: func() *Dagger { - d := NewDaggerStore() - return d - }(), - }, - args: args{ - node: Node{ - objType: "pod", - name: "test-pod", - namespace: "test-namespace", - }, - key: "test-key", - }, - want: nil, - wantErr: true, - }, - } - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - got, err := tt.fields.d.GetNodeAttribute(tt.args.node, tt.args.key) - if (err != nil) != tt.wantErr { - t.Errorf("Dagger.GetNodeAttribute() error = %v, wantErr %v", err, tt.wantErr) - return - } - if !reflect.DeepEqual(got, tt.want) { - t.Errorf("Dagger.GetNodeAttribute() = %v, want %v", got, tt.want) - } - }) - } -} - -func TestDagger_SetNodeAttributes(t *testing.T) { - type fields struct { - d *Dagger - } - type args struct { - node Node - attributes map[string]interface{} - } - tests := []struct { - name string - fields fields - args args - want map[string]interface{} - wantErr bool - }{ - { - name: "add multiple attributes", - fields: fields{ - d: func() *Dagger { - d := NewDaggerStore() - d.AddNode(Node{ - name: "test-pod", - namespace: "test-namespace", - objType: "pod", - }) - return d - }(), - }, - args: args{ - node: Node{ - objType: "pod", - name: "test-pod", - namespace: "test-namespace", - }, - attributes: map[string]interface{}{ - "test-key": "test-value", - "test-key2": "test-value2", - }, - }, - want: map[string]interface{}{ - ReservedAttributeNodeType: "pod", - ReservedAttributeName: "test-pod", - ReservedAttributeNamespace: "test-namespace", - "test-key": "test-value", - "test-key2": "test-value2", - }, - wantErr: false, - }, - { - name: "node not found", - fields: fields{ - d: func() *Dagger { - d := NewDaggerStore() - return d - }(), - }, - args: args{ - node: Node{ - objType: "pod", - name: "test-pod", - namespace: "test-namespace", - }, - attributes: map[string]interface{}{}, - }, - want: nil, - wantErr: true, - }, - { - name: "nil attributes", - fields: fields{ - d: func() *Dagger { - d := NewDaggerStore() - d.AddNode(Node{ - name: "test-pod", - namespace: "test-namespace", - objType: "pod", - attributes: nil, - }) - return d - }(), - }, - args: args{ - node: Node{ - objType: "pod", - name: "test-pod", - namespace: "test-namespace", - }, - attributes: nil, - }, - want: map[string]interface{}{ - ReservedAttributeNodeType: "pod", - ReservedAttributeName: "test-pod", - ReservedAttributeNamespace: "test-namespace", - }, - wantErr: false, - }, - } - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - got, err := tt.fields.d.SetNodeAttributes(tt.args.node, tt.args.attributes) - if (err != nil) != tt.wantErr { - t.Errorf("Dagger.SetNodeAttributes() error = %v, wantErr %v", err, tt.wantErr) - return - } - if !reflect.DeepEqual(got, tt.want) { - t.Errorf("Dagger.SetNodeAttributes() = %v, want %v", got, tt.want) - } - }) - } -} - -func TestDagger_SetNodeAttribute(t *testing.T) { - type fields struct { - d *Dagger - } - type args struct { - node Node - key string - value interface{} - } - tests := []struct { - name string - fields fields - args args - want map[string]interface{} - wantErr bool - }{ - { - name: "add attribute", - fields: fields{ - d: func() *Dagger { - d := NewDaggerStore() - d.AddNode(Node{ - name: "test-pod", - namespace: "test-namespace", - objType: "pod", - }) - return d - }(), - }, - args: args{ - node: Node{ - objType: "pod", - name: "test-pod", - namespace: "test-namespace", - }, - key: "test-key", - value: "test-value", - }, - want: map[string]interface{}{ - ReservedAttributeNodeType: "pod", - ReservedAttributeName: "test-pod", - ReservedAttributeNamespace: "test-namespace", - "test-key": "test-value", - }, - wantErr: false, - }, - { - name: "node not found", - fields: fields{ - d: func() *Dagger { - d := NewDaggerStore() - return d - }(), - }, - args: args{ - node: Node{ - objType: "pod", - name: "test-pod", - namespace: "test-namespace", - }, - key: "test-key", - value: "test-value", - }, - want: nil, - wantErr: true, - }, - { - name: "nil attribute value", - fields: fields{ - d: func() *Dagger { - d := NewDaggerStore() - d.AddNode(Node{ - name: "test-pod", - namespace: "test-namespace", - objType: "pod", - attributes: nil, - }) - return d - }(), - }, - args: args{ - node: Node{ - objType: "pod", - name: "test-pod", - namespace: "test-namespace", - }, - key: "test-key", - value: nil, - }, - want: nil, - wantErr: true, - }, - } - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - got, err := tt.fields.d.SetNodeAttribute(tt.args.node, tt.args.key, tt.args.value) - if (err != nil) != tt.wantErr { - t.Errorf("Dagger.SetNodeAttributes() error = %v, wantErr %v", err, tt.wantErr) - return - } - if !reflect.DeepEqual(got, tt.want) { - t.Errorf("Dagger.SetNodeAttributes() = %v, want %v", got, tt.want) - } - }) - } -} - -func TestDagger_DelNodeAttribute(t *testing.T) { - type fields struct { - d *Dagger - } - type args struct { - node Node - key string - } - tests := []struct { - name string - fields fields - args args - want map[string]interface{} - wantErr bool - }{ - { - name: "attribute exists", - fields: fields{ - d: func() *Dagger { - d := NewDaggerStore() - d.AddNode(Node{ - name: "test-pod", - namespace: "test-namespace", - objType: "pod", - attributes: map[string]interface{}{ - "test-key": "test-value", - }, - }) - return d - }(), - }, - args: args{ - node: Node{ - objType: "pod", - name: "test-pod", - namespace: "test-namespace", - }, - key: "test-key", - }, - want: map[string]interface{}{ - ReservedAttributeNodeType: "pod", - ReservedAttributeName: "test-pod", - ReservedAttributeNamespace: "test-namespace", - }, - wantErr: false, - }, - { - name: "node not found", - fields: fields{ - d: func() *Dagger { - d := NewDaggerStore() - return d - }(), - }, - args: args{ - node: Node{ - objType: "pod", - name: "test-pod", - namespace: "test-namespace", - }, - key: "test-key", - }, - want: nil, - wantErr: true, - }, - { - name: "attribute does not exist", - fields: fields{ - d: func() *Dagger { - d := NewDaggerStore() - d.AddNode(Node{ - name: "test-pod", - namespace: "test-namespace", - objType: "pod", - attributes: nil, - }) - return d - }(), - }, - args: args{ - node: Node{ - objType: "pod", - name: "test-pod", - namespace: "test-namespace", - }, - key: "test-key", - }, - want: map[string]interface{}{ - ReservedAttributeNodeType: "pod", - ReservedAttributeName: "test-pod", - ReservedAttributeNamespace: "test-namespace", - }, - wantErr: false, - }, - } - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - got, err := tt.fields.d.DelNodeAttribute(tt.args.node, tt.args.key) - if (err != nil) != tt.wantErr { - t.Errorf("Dagger.SetNodeAttributes() error = %v, wantErr %v", err, tt.wantErr) - return - } - if !reflect.DeepEqual(got, tt.want) { - t.Errorf("Dagger.SetNodeAttributes() = %v, want %v", got, tt.want) - } - }) - } -} - -func TestDagger_AddEdge(t *testing.T) { - type fields struct { - d *Dagger - } - type args struct { - edge Edge - } - tests := []struct { - name string - fields fields - args args - wantErr bool - }{ - { - name: "adds an edge to the graph", - fields: fields{ - d: func() *Dagger { - d := NewDaggerStore() - d.AddNode(Node{ - name: "test-pod", - namespace: "test-namespace", - objType: "pod", - attributes: nil, - }) - d.AddNode(Node{ - name: "test-service", - namespace: "test-namespace", - objType: "service", - attributes: nil, - }) - return d - }(), - }, - args: args{ - edge: Edge{ - from: Node{ - name: "test-pod", - namespace: "test-namespace", - objType: "pod", - }, - to: Node{ - name: "test-service", - namespace: "test-namespace", - objType: "service", - }, - attributes: nil, - }, - }, - wantErr: false, - }, - { - name: "to node not found", - fields: fields{ - d: func() *Dagger { - d := NewDaggerStore() - d.AddNode(Node{ - name: "test-pod", - namespace: "test-namespace", - objType: "pod", - attributes: nil, - }) - return d - }(), - }, - args: args{ - edge: Edge{ - from: Node{ - name: "test-pod", - namespace: "test-namespace", - objType: "pod", - }, - to: Node{ - name: "test-service", - namespace: "test-namespace", - objType: "service", - }, - attributes: nil, - }, - }, - wantErr: true, - }, - { - name: "from node not found", - fields: fields{ - d: func() *Dagger { - d := NewDaggerStore() - d.AddNode(Node{ - name: "test-svx", - namespace: "test-namespace", - objType: "service", - attributes: nil, - }) - return d - }(), - }, - args: args{ - edge: Edge{ - from: Node{ - name: "test-pod", - namespace: "test-namespace", - objType: "pod", - }, - to: Node{ - name: "test-service", - namespace: "test-namespace", - objType: "service", - }, - attributes: nil, - }, - }, - wantErr: true, - }, - } - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - if err := tt.fields.d.AddEdge(tt.args.edge); (err != nil) != tt.wantErr { - t.Errorf("Dagger.AddEdge() error = %v, wantErr %v", err, tt.wantErr) - } - }) - } -} - -func TestDagger_GetEdgeNodes(t *testing.T) { - type fields struct { - d *Dagger - } - type args struct { - edge Edge - } - tests := []struct { - name string - fields fields - args args - want Node - want1 Node - wantErr bool - }{ - { - name: "gets the edge nodes", - fields: fields{ - d: func() *Dagger { - d := NewDaggerStore() - from := Node{ - name: "test-pod", - namespace: "test-namespace", - objType: "pod", - attributes: nil, - } - to := Node{ - name: "test-service", - namespace: "test-namespace", - objType: "service", - attributes: nil, - } - d.AddNode(from) - d.AddNode(to) - _ = d.AddEdge(Edge{ - from: from, - to: to, - attributes: map[string]interface{}{ - "test-key": "test-value", - }, - }) - return d - }(), - }, - args: args{ - edge: Edge{ - from: Node{ - name: "test-pod", - namespace: "test-namespace", - objType: "pod", - }, - to: Node{ - name: "test-service", - namespace: "test-namespace", - objType: "service", - }, - attributes: map[string]interface{}{ - "test-key": "test-value", - }, - }, - }, - want: Node{ - name: "test-pod", - namespace: "test-namespace", - objType: "pod", - attributes: map[string]interface{}{ - ReservedAttributeNodeType: "pod", - ReservedAttributeName: "test-pod", - ReservedAttributeNamespace: "test-namespace", - }, - }, - want1: Node{ - name: "test-service", - namespace: "test-namespace", - objType: "service", - attributes: map[string]interface{}{ - ReservedAttributeNodeType: "service", - ReservedAttributeName: "test-service", - ReservedAttributeNamespace: "test-namespace", - }, - }, - wantErr: false, - }, - { - name: "edge does not exist", - fields: fields{ - d: func() *Dagger { - d := NewDaggerStore() - from := Node{ - name: "test-pod", - namespace: "test-namespace", - objType: "pod", - attributes: nil, - } - to := Node{ - name: "test-service", - namespace: "test-namespace", - objType: "service", - attributes: nil, - } - d.AddNode(from) - d.AddNode(to) - return d - }(), - }, - args: args{ - edge: Edge{ - from: Node{ - name: "test-pod", - namespace: "test-namespace", - objType: "pod", - }, - to: Node{ - name: "test-service", - namespace: "test-namespace", - objType: "service", - }, - attributes: map[string]interface{}{ - "test-key": "test-value", - }, - }, - }, - want: Node{}, - want1: Node{}, - wantErr: true, - }, - } - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - got, got1, err := tt.fields.d.GetEdgeNodes(tt.args.edge) - if (err != nil) != tt.wantErr { - t.Errorf("Dagger.GetEdgeNodes() error = %v, wantErr %v", err, tt.wantErr) - return - } - if !reflect.DeepEqual(got, tt.want) { - t.Errorf("Dagger.GetEdgeNodes() got = %v, want %v", got, tt.want) - } - if !reflect.DeepEqual(got1, tt.want1) { - t.Errorf("Dagger.GetEdgeNodes() got1 = %v, want %v", got1, tt.want1) - } - }) - } -} - -func TestDagger_GetEdgeAttribute(t *testing.T) { - type fields struct { - d *Dagger - } - type args struct { - edge Edge - key string - } - tests := []struct { - name string - fields fields - args args - want interface{} - wantErr bool - }{ - { - name: "attribute exists", - fields: fields{ - d: func() *Dagger { - d := NewDaggerStore() - from := Node{ - name: "test-pod", - namespace: "test-namespace", - objType: "pod", - attributes: nil, - } - to := Node{ - name: "test-service", - namespace: "test-namespace", - objType: "service", - attributes: nil, - } - d.AddNode(from) - d.AddNode(to) - d.AddEdge(Edge{ - from: from, - to: to, - attributes: map[string]interface{}{ - "test-key": "test-value", - }, - }) - return d - }(), - }, - args: args{ - edge: Edge{ - from: Node{ - name: "test-pod", - namespace: "test-namespace", - objType: "pod", - attributes: nil, - }, - to: Node{ - name: "test-service", - namespace: "test-namespace", - objType: "service", - attributes: nil, - }, - }, - key: "test-key", - }, - want: "test-value", - wantErr: false, - }, - { - name: "attribute does not exist", - fields: fields{ - d: func() *Dagger { - d := NewDaggerStore() - from := Node{ - name: "test-pod", - namespace: "test-namespace", - objType: "pod", - attributes: nil, - } - to := Node{ - name: "test-service", - namespace: "test-namespace", - objType: "service", - attributes: nil, - } - d.AddNode(from) - d.AddNode(to) - d.AddEdge(Edge{ - from: from, - to: to, - attributes: nil, - }) - return d - }(), - }, - args: args{ - edge: Edge{ - from: Node{ - name: "test-pod", - namespace: "test-namespace", - objType: "pod", - attributes: nil, - }, - to: Node{ - name: "test-service", - namespace: "test-namespace", - objType: "service", - attributes: nil, - }, - }, - key: "test-key", - }, - want: nil, - wantErr: true, - }, - { - name: "edge does not exist", - fields: fields{ - d: func() *Dagger { - d := NewDaggerStore() - from := Node{ - name: "test-pod", - namespace: "test-namespace", - objType: "pod", - attributes: nil, - } - to := Node{ - name: "test-service", - namespace: "test-namespace", - objType: "service", - attributes: nil, - } - d.AddNode(from) - d.AddNode(to) - return d - }(), - }, - args: args{ - edge: Edge{ - from: Node{ - name: "test-pod", - namespace: "test-namespace", - objType: "pod", - attributes: nil, - }, - to: Node{ - name: "test-service", - namespace: "test-namespace", - objType: "service", - attributes: nil, - }, - }, - key: "test-key", - }, - want: nil, - wantErr: true, - }, - } - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - got, err := tt.fields.d.GetEdgeAttribute(tt.args.edge, tt.args.key) - if (err != nil) != tt.wantErr { - t.Errorf("Dagger.GetEdgeAttribute() error = %v, wantErr %v", err, tt.wantErr) - return - } - if !reflect.DeepEqual(got, tt.want) { - t.Errorf("Dagger.GetEdgeAttribute() = %v, want %v", got, tt.want) - } - }) - } -} - -func TestDagger_GetEdgeAttributes(t *testing.T) { - type fields struct { - d *Dagger - } - type args struct { - edge Edge - } - tests := []struct { - name string - fields fields - args args - want map[string]interface{} - wantErr bool - }{ - { - name: "with additional attributes", - fields: fields{ - d: func() *Dagger { - d := NewDaggerStore() - from := Node{ - name: "test-pod", - namespace: "test-namespace", - objType: "pod", - attributes: nil, - } - to := Node{ - name: "test-service", - namespace: "test-namespace", - objType: "service", - attributes: nil, - } - d.AddNode(from) - d.AddNode(to) - d.AddEdge(Edge{ - from: from, - to: to, - attributes: map[string]interface{}{ - "test-key": "test-value", - }, - }) - return d - }(), - }, - args: args{ - edge: Edge{ - from: Node{ - name: "test-pod", - namespace: "test-namespace", - objType: "pod", - attributes: nil, - }, - to: Node{ - name: "test-service", - namespace: "test-namespace", - objType: "service", - attributes: nil, - }, - }, - }, - want: map[string]interface{}{ - ReservedAttributeEdgeType: EdgeXTypeConnection, - "from_" + ReservedAttributeNodeType: NodeXTypeFromString("pod"), - "to_" + ReservedAttributeNodeType: NodeXTypeFromString("service"), - "from_" + ReservedAttributeName: "test-pod", - "from_" + ReservedAttributeNamespace: "test-namespace", - "from_" + ReservedAttributeXID: generateNodeXID("test-pod", "test-namespace"), - "to_" + ReservedAttributeName: "test-service", - "to_" + ReservedAttributeNamespace: "test-namespace", - "to_" + ReservedAttributeXID: generateNodeXID("test-service", "test-namespace"), - "test-key": "test-value", - }, - wantErr: false, - }, - { - name: "with nil attributes", - fields: fields{ - d: func() *Dagger { - d := NewDaggerStore() - from := Node{ - name: "test-pod", - namespace: "test-namespace", - objType: "pod", - attributes: nil, - } - to := Node{ - name: "test-service", - namespace: "test-namespace", - objType: "service", - attributes: nil, - } - d.AddNode(from) - d.AddNode(to) - d.AddEdge(Edge{ - from: from, - to: to, - attributes: nil, - }) - return d - }(), - }, - args: args{ - edge: Edge{ - from: Node{ - name: "test-pod", - namespace: "test-namespace", - objType: "pod", - attributes: nil, - }, - to: Node{ - name: "test-service", - namespace: "test-namespace", - objType: "service", - attributes: nil, - }, - }, - }, - want: map[string]interface{}{ - ReservedAttributeEdgeType: EdgeXTypeConnection, - "from_" + ReservedAttributeNodeType: NodeXTypeFromString("pod"), - "to_" + ReservedAttributeNodeType: NodeXTypeFromString("service"), - "from_" + ReservedAttributeName: "test-pod", - "from_" + ReservedAttributeNamespace: "test-namespace", - "from_" + ReservedAttributeXID: generateNodeXID("test-pod", "test-namespace"), - "to_" + ReservedAttributeName: "test-service", - "to_" + ReservedAttributeNamespace: "test-namespace", - "to_" + ReservedAttributeXID: generateNodeXID("test-service", "test-namespace"), - }, - wantErr: false, - }, - { - name: "edge does not exist", - fields: fields{ - d: func() *Dagger { - d := NewDaggerStore() - from := Node{ - name: "test-pod", - namespace: "test-namespace", - objType: "pod", - attributes: nil, - } - to := Node{ - name: "test-service", - namespace: "test-namespace", - objType: "service", - attributes: nil, - } - d.AddNode(from) - d.AddNode(to) - return d - }(), - }, - args: args{ - edge: Edge{ - from: Node{ - name: "test-pod", - namespace: "test-namespace", - objType: "pod", - attributes: nil, - }, - to: Node{ - name: "test-service", - namespace: "test-namespace", - objType: "service", - attributes: nil, - }, - }, - }, - want: nil, - wantErr: true, - }, - } - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - got, err := tt.fields.d.GetEdgeAttributes(tt.args.edge) - if (err != nil) != tt.wantErr { - t.Errorf("Dagger.GetEdgeAttributes() error = %v, wantErr %v", err, tt.wantErr) - return - } - if !reflect.DeepEqual(got, tt.want) { - t.Errorf("Dagger.GetEdgeAttributes() = %v, want %v", got, tt.want) - } - }) - } -} - -func TestDagger_SetEdgeAttributes(t *testing.T) { - type fields struct { - d *Dagger - } - type args struct { - edge Edge - attributes map[string]interface{} - } - tests := []struct { - name string - fields fields - args args - want map[string]interface{} - wantErr bool - }{ - { - name: "add multiple attributes", - fields: fields{ - d: func() *Dagger { - d := NewDaggerStore() - from := Node{ - name: "test-pod", - namespace: "test-namespace", - objType: "pod", - attributes: nil, - } - to := Node{ - name: "test-service", - namespace: "test-namespace", - objType: "service", - attributes: nil, - } - d.AddNode(from) - d.AddNode(to) - d.AddEdge(Edge{ - from: from, - to: to, - attributes: nil, - }) - return d - }(), - }, - args: args{ - edge: Edge{ - from: Node{ - name: "test-pod", - namespace: "test-namespace", - objType: "pod", - }, - to: Node{ - name: "test-service", - namespace: "test-namespace", - objType: "service", - attributes: nil, - }, - }, - attributes: map[string]interface{}{ - "test-key": "test-value", - "test-key2": "test-value2", - }, - }, - want: map[string]interface{}{ - ReservedAttributeEdgeType: EdgeXTypeConnection, - "from_" + ReservedAttributeNodeType: NodeXTypeFromString("pod"), - "to_" + ReservedAttributeNodeType: NodeXTypeFromString("service"), - "from_" + ReservedAttributeName: "test-pod", - "from_" + ReservedAttributeNamespace: "test-namespace", - "from_" + ReservedAttributeXID: generateNodeXID("test-pod", "test-namespace"), - "to_" + ReservedAttributeName: "test-service", - "to_" + ReservedAttributeNamespace: "test-namespace", - "to_" + ReservedAttributeXID: generateNodeXID("test-service", "test-namespace"), - "test-key": "test-value", - "test-key2": "test-value2", - }, - wantErr: false, - }, - { - name: "edge does not exist", - fields: fields{ - d: func() *Dagger { - d := NewDaggerStore() - from := Node{ - name: "test-pod", - namespace: "test-namespace", - objType: "pod", - attributes: nil, - } - to := Node{ - name: "test-service", - namespace: "test-namespace", - objType: "service", - attributes: nil, - } - d.AddNode(from) - d.AddNode(to) - return d - }(), - }, - args: args{ - edge: Edge{ - from: Node{ - name: "test-pod", - namespace: "test-namespace", - objType: "pod", - attributes: nil, - }, - to: Node{ - name: "test-service", - namespace: "test-namespace", - objType: "service", - attributes: nil, - }, - }, - }, - want: nil, - wantErr: true, - }, - { - name: "add nil attributes", - fields: fields{ - d: func() *Dagger { - d := NewDaggerStore() - from := Node{ - name: "test-pod", - namespace: "test-namespace", - objType: "pod", - attributes: nil, - } - to := Node{ - name: "test-service", - namespace: "test-namespace", - objType: "service", - attributes: nil, - } - d.AddNode(from) - d.AddNode(to) - d.AddEdge(Edge{ - from: from, - to: to, - attributes: nil, - }) - return d - }(), - }, - args: args{ - edge: Edge{ - from: Node{ - name: "test-pod", - namespace: "test-namespace", - objType: "pod", - }, - to: Node{ - name: "test-service", - namespace: "test-namespace", - objType: "service", - attributes: nil, - }, - }, - attributes: nil, - }, - want: map[string]interface{}{ - ReservedAttributeEdgeType: EdgeXTypeConnection, - "from_" + ReservedAttributeNodeType: NodeXTypeFromString("pod"), - "to_" + ReservedAttributeNodeType: NodeXTypeFromString("service"), - "from_" + ReservedAttributeName: "test-pod", - "from_" + ReservedAttributeNamespace: "test-namespace", - "from_" + ReservedAttributeXID: generateNodeXID("test-pod", "test-namespace"), - "to_" + ReservedAttributeName: "test-service", - "to_" + ReservedAttributeNamespace: "test-namespace", - "to_" + ReservedAttributeXID: generateNodeXID("test-service", "test-namespace"), - }, - wantErr: false, - }, - } - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - got, err := tt.fields.d.SetEdgeAttributes(tt.args.edge, tt.args.attributes) - if (err != nil) != tt.wantErr { - t.Errorf("Dagger.SetEdgeAttributes() error = %v, wantErr %v", err, tt.wantErr) - return - } - if !reflect.DeepEqual(got, tt.want) { - t.Errorf("Dagger.SetEdgeAttributes() = %v, want %v", got, tt.want) - } - }) - } -} - -func TestDagger_SetEdgeAttribute(t *testing.T) { - type fields struct { - d *Dagger - } - type args struct { - edge Edge - key string - value interface{} - } - tests := []struct { - name string - fields fields - args args - want map[string]interface{} - wantErr bool - }{ - { - name: "add new attributes", - fields: fields{ - d: func() *Dagger { - d := NewDaggerStore() - from := Node{ - name: "test-pod", - namespace: "test-namespace", - objType: "pod", - attributes: nil, - } - to := Node{ - name: "test-service", - namespace: "test-namespace", - objType: "service", - attributes: nil, - } - d.AddNode(from) - d.AddNode(to) - d.AddEdge(Edge{ - from: from, - to: to, - attributes: nil, - }) - return d - }(), - }, - args: args{ - edge: Edge{ - from: Node{ - name: "test-pod", - namespace: "test-namespace", - objType: "pod", - }, - to: Node{ - name: "test-service", - namespace: "test-namespace", - objType: "service", - attributes: nil, - }, - }, - key: "test-key", - value: "test-value", - }, - want: map[string]interface{}{ - ReservedAttributeEdgeType: EdgeXTypeConnection, - "from_" + ReservedAttributeNodeType: NodeXTypeFromString("pod"), - "to_" + ReservedAttributeNodeType: NodeXTypeFromString("service"), - "from_" + ReservedAttributeName: "test-pod", - "from_" + ReservedAttributeNamespace: "test-namespace", - "from_" + ReservedAttributeXID: generateNodeXID("test-pod", "test-namespace"), - "to_" + ReservedAttributeName: "test-service", - "to_" + ReservedAttributeNamespace: "test-namespace", - "to_" + ReservedAttributeXID: generateNodeXID("test-service", "test-namespace"), - "test-key": "test-value", - }, - wantErr: false, - }, - { - name: "edge does not exist", - fields: fields{ - d: func() *Dagger { - d := NewDaggerStore() - from := Node{ - name: "test-pod", - namespace: "test-namespace", - objType: "pod", - attributes: nil, - } - to := Node{ - name: "test-service", - namespace: "test-namespace", - objType: "service", - attributes: nil, - } - d.AddNode(from) - d.AddNode(to) - return d - }(), - }, - args: args{ - edge: Edge{ - from: Node{ - name: "test-pod", - namespace: "test-namespace", - objType: "pod", - attributes: nil, - }, - to: Node{ - name: "test-service", - namespace: "test-namespace", - objType: "service", - attributes: nil, - }, - }, - key: "test-key", - value: "test-value", - }, - want: nil, - wantErr: true, - }, - } - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - got, err := tt.fields.d.SetEdgeAttribute(tt.args.edge, tt.args.key, tt.args.value) - if (err != nil) != tt.wantErr { - t.Errorf("Dagger.SetEdgeAttribute() error = %v, wantErr %v", err, tt.wantErr) - return - } - if !reflect.DeepEqual(got, tt.want) { - t.Errorf("Dagger.SetEdgeAttribute() = %v, want %v", got, tt.want) - } - }) - } -} - -func TestDagger_DelEdgeAttribute(t *testing.T) { - type fields struct { - d *Dagger - } - type args struct { - edge Edge - key string - } - tests := []struct { - name string - fields fields - args args - want map[string]interface{} - wantErr bool - }{ - { - name: "delete existing attributes", - fields: fields{ - d: func() *Dagger { - d := NewDaggerStore() - from := Node{ - name: "test-pod", - namespace: "test-namespace", - objType: "pod", - attributes: nil, - } - to := Node{ - name: "test-service", - namespace: "test-namespace", - objType: "service", - attributes: nil, - } - d.AddNode(from) - d.AddNode(to) - d.AddEdge(Edge{ - from: from, - to: to, - attributes: map[string]interface{}{ - "test-key": "test-value", - "test-key2": "test-value2", - }, - }) - return d - }(), - }, - args: args{ - edge: Edge{ - from: Node{ - name: "test-pod", - namespace: "test-namespace", - objType: "pod", - }, - to: Node{ - name: "test-service", - namespace: "test-namespace", - objType: "service", - attributes: nil, - }, - }, - key: "test-key", - }, - want: map[string]interface{}{ - ReservedAttributeEdgeType: EdgeXTypeConnection, - "from_" + ReservedAttributeNodeType: NodeXTypeFromString("pod"), - "to_" + ReservedAttributeNodeType: NodeXTypeFromString("service"), - "from_" + ReservedAttributeName: "test-pod", - "from_" + ReservedAttributeNamespace: "test-namespace", - "from_" + ReservedAttributeXID: generateNodeXID("test-pod", "test-namespace"), - "to_" + ReservedAttributeName: "test-service", - "to_" + ReservedAttributeNamespace: "test-namespace", - "to_" + ReservedAttributeXID: generateNodeXID("test-service", "test-namespace"), - "test-key2": "test-value2", - }, - wantErr: false, - }, - { - name: "delete missing attributes", - fields: fields{ - d: func() *Dagger { - d := NewDaggerStore() - from := Node{ - name: "test-pod", - namespace: "test-namespace", - objType: "pod", - attributes: nil, - } - to := Node{ - name: "test-service", - namespace: "test-namespace", - objType: "service", - attributes: nil, - } - d.AddNode(from) - d.AddNode(to) - d.AddEdge(Edge{ - from: from, - to: to, - attributes: map[string]interface{}{ - "test-key2": "test-value2", - }, - }) - return d - }(), - }, - args: args{ - edge: Edge{ - from: Node{ - name: "test-pod", - namespace: "test-namespace", - objType: "pod", - }, - to: Node{ - name: "test-service", - namespace: "test-namespace", - objType: "service", - attributes: nil, - }, - }, - key: "test-key", - }, - want: map[string]interface{}{ - ReservedAttributeEdgeType: EdgeXTypeConnection, - "from_" + ReservedAttributeNodeType: NodeXTypeFromString("pod"), - "to_" + ReservedAttributeNodeType: NodeXTypeFromString("service"), - "from_" + ReservedAttributeName: "test-pod", - "from_" + ReservedAttributeNamespace: "test-namespace", - "from_" + ReservedAttributeXID: generateNodeXID("test-pod", "test-namespace"), - "to_" + ReservedAttributeName: "test-service", - "to_" + ReservedAttributeNamespace: "test-namespace", - "to_" + ReservedAttributeXID: generateNodeXID("test-service", "test-namespace"), - "test-key2": "test-value2", - }, - wantErr: false, - }, - { - name: "edge does not exist", - fields: fields{ - d: func() *Dagger { - d := NewDaggerStore() - from := Node{ - name: "test-pod", - namespace: "test-namespace", - objType: "pod", - attributes: nil, - } - to := Node{ - name: "test-service", - namespace: "test-namespace", - objType: "service", - attributes: nil, - } - d.AddNode(from) - d.AddNode(to) - return d - }(), - }, - args: args{ - edge: Edge{ - from: Node{ - name: "test-pod", - namespace: "test-namespace", - objType: "pod", - attributes: nil, - }, - to: Node{ - name: "test-service", - namespace: "test-namespace", - objType: "service", - attributes: nil, - }, - }, - key: "test-key", - }, - want: nil, - wantErr: true, - }, - } - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - got, err := tt.fields.d.DelEdgeAttribute(tt.args.edge, tt.args.key) - if (err != nil) != tt.wantErr { - t.Errorf("Dagger.DelEdgeAttribute() error = %v, wantErr %v", err, tt.wantErr) - return - } - if !reflect.DeepEqual(got, tt.want) { - t.Errorf("Dagger.DelEdgeAttribute() = %v, want %v", got, tt.want) - } - }) - } -} - -func TestDagger_ListOutboundEdges(t *testing.T) { - type fields struct { - d *Dagger - } - type args struct { - node Node - } - tests := []struct { - name string - fields fields - args args - want []Edge - wantErr bool - }{ - { - name: "list two outbound edges", - fields: fields{ - d: func() *Dagger { - d := NewDaggerStore() - from := Node{ - name: "test-pod", - namespace: "test-namespace", - objType: "pod", - attributes: nil, - } - toSvc := Node{ - name: "test-service", - namespace: "test-namespace", - objType: "service", - attributes: nil, - } - toPod := Node{ - name: "test-pod2", - namespace: "test-namespace", - objType: "pod", - attributes: nil, - } - d.AddNode(from) - d.AddNode(toSvc) - d.AddNode(toPod) - - d.AddEdge(Edge{ - from: from, - to: toSvc, - attributes: map[string]interface{}{ - "test-key": "test-value", - }, - }) - d.AddEdge(Edge{ - from: from, - to: toPod, - attributes: map[string]interface{}{ - "test-key": "test-value", - }, - }) - return d - }(), - }, - args: args{ - node: Node{ - name: "test-pod", - namespace: "test-namespace", - objType: "pod", - }, - }, - want: []Edge{ - { - from: Node{ - name: "test-pod", - namespace: "test-namespace", - objType: "pod", - attributes: nil, - }, - to: Node{ - name: "test-service", - namespace: "test-namespace", - objType: "service", - attributes: nil, - }, - attributes: map[string]interface{}{ - ReservedAttributeEdgeType: EdgeXTypeConnection, - "from_" + ReservedAttributeNodeType: NodeXTypeFromString("pod"), - "to_" + ReservedAttributeNodeType: NodeXTypeFromString("service"), - "from_" + ReservedAttributeName: "test-pod", - "from_" + ReservedAttributeNamespace: "test-namespace", - "from_" + ReservedAttributeXID: generateNodeXID("test-pod", "test-namespace"), - "to_" + ReservedAttributeName: "test-service", - "to_" + ReservedAttributeNamespace: "test-namespace", - "to_" + ReservedAttributeXID: generateNodeXID("test-service", "test-namespace"), - "test-key": "test-value", - }, - }, - { - from: Node{ - name: "test-pod", - namespace: "test-namespace", - objType: "pod", - attributes: nil, - }, - to: Node{ - name: "test-pod2", - namespace: "test-namespace", - objType: "pod", - attributes: nil, - }, - attributes: map[string]interface{}{ - ReservedAttributeEdgeType: EdgeXTypeConnection, - "from_" + ReservedAttributeNodeType: NodeXTypeFromString("pod"), - "to_" + ReservedAttributeNodeType: NodeXTypeFromString("pod"), - "from_" + ReservedAttributeName: "test-pod", - "from_" + ReservedAttributeNamespace: "test-namespace", - "from_" + ReservedAttributeXID: generateNodeXID("test-pod", "test-namespace"), - "to_" + ReservedAttributeName: "test-pod2", - "to_" + ReservedAttributeNamespace: "test-namespace", - "to_" + ReservedAttributeXID: generateNodeXID("test-pod2", "test-namespace"), - "test-key": "test-value", - }, - }, - }, - wantErr: false, - }, - } - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - got, err := tt.fields.d.ListOutboundEdges(tt.args.node) - if (err != nil) != tt.wantErr { - t.Errorf("Dagger.ListOutboundEdges() error = %v, wantErr %v", err, tt.wantErr) - return - } - if !arrayEqualEdge(got, tt.want) { - t.Errorf("Dagger.ListOutboundEdges() = %v, want %v", got, tt.want) - } - }) - } -} - -func TestDagger_ListInboundEdges(t *testing.T) { - type fields struct { - d *Dagger - } - type args struct { - node Node - } - tests := []struct { - name string - fields fields - args args - want []Edge - wantErr bool - }{ - { - name: "list two inbound edges", - fields: fields{ - d: func() *Dagger { - d := NewDaggerStore() - to := Node{ - name: "test-pod", - namespace: "test-namespace", - objType: "pod", - attributes: nil, - } - fromSvc := Node{ - name: "test-service", - namespace: "test-namespace", - objType: "service", - attributes: nil, - } - fromPod := Node{ - name: "test-pod2", - namespace: "test-namespace", - objType: "pod", - attributes: nil, - } - d.AddNode(to) - d.AddNode(fromSvc) - d.AddNode(fromPod) - - d.AddEdge(Edge{ - from: fromSvc, - to: to, - attributes: map[string]interface{}{ - "test-key": "test-value", - }, - }) - d.AddEdge(Edge{ - from: fromPod, - to: to, - attributes: map[string]interface{}{ - "test-key": "test-value", - }, - }) - return d - }(), - }, - args: args{ - node: Node{ - name: "test-pod", - namespace: "test-namespace", - objType: "pod", - }, - }, - want: []Edge{ - { - to: Node{ - name: "test-pod", - namespace: "test-namespace", - objType: "pod", - attributes: nil, - }, - from: Node{ - name: "test-service", - namespace: "test-namespace", - objType: "service", - attributes: nil, - }, - attributes: map[string]interface{}{ - ReservedAttributeEdgeType: EdgeXTypeConnection, - "to_" + ReservedAttributeNodeType: NodeXTypeFromString("pod"), - "from_" + ReservedAttributeNodeType: NodeXTypeFromString("service"), - "to_" + ReservedAttributeName: "test-pod", - "to_" + ReservedAttributeNamespace: "test-namespace", - "to_" + ReservedAttributeXID: generateNodeXID("test-pod", "test-namespace"), - "from_" + ReservedAttributeName: "test-service", - "from_" + ReservedAttributeNamespace: "test-namespace", - "from_" + ReservedAttributeXID: generateNodeXID("test-service", "test-namespace"), - "test-key": "test-value", - }, - }, - { - to: Node{ - name: "test-pod", - namespace: "test-namespace", - objType: "pod", - attributes: nil, - }, - from: Node{ - name: "test-pod2", - namespace: "test-namespace", - objType: "pod", - attributes: nil, - }, - attributes: map[string]interface{}{ - ReservedAttributeEdgeType: EdgeXTypeConnection, - "to_" + ReservedAttributeNodeType: NodeXTypeFromString("pod"), - "from_" + ReservedAttributeNodeType: NodeXTypeFromString("pod"), - "to_" + ReservedAttributeName: "test-pod", - "to_" + ReservedAttributeNamespace: "test-namespace", - "to_" + ReservedAttributeXID: generateNodeXID("test-pod", "test-namespace"), - "from_" + ReservedAttributeName: "test-pod2", - "from_" + ReservedAttributeNamespace: "test-namespace", - "from_" + ReservedAttributeXID: generateNodeXID("test-pod2", "test-namespace"), - "test-key": "test-value", - }, - }, - }, - wantErr: false, - }, - } - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - got, err := tt.fields.d.ListInboundEdges(tt.args.node) - if (err != nil) != tt.wantErr { - t.Errorf("Dagger.ListInboundEdges() error = %v, wantErr %v", err, tt.wantErr) - return - } - if !arrayEqualEdge(got, tt.want) { - t.Errorf("Dagger.ListInboundEdges() = %v, want %v", got, tt.want) - } - }) - } -} - -func TestDagger_ListNodes(t *testing.T) { - type fields struct { - d *Dagger - } - tests := []struct { - name string - fields fields - want []Node - wantErr bool - }{ - { - name: "list all graph nodes", - fields: fields{ - d: func() *Dagger { - d := NewDaggerStore() - to := Node{ - name: "test-pod", - namespace: "test-namespace", - objType: "pod", - attributes: nil, - } - fromSvc := Node{ - name: "test-service", - namespace: "test-namespace", - objType: "service", - attributes: nil, - } - fromPod := Node{ - name: "test-pod2", - namespace: "test-namespace", - objType: "pod", - attributes: nil, - } - d.AddNode(to) - d.AddNode(fromSvc) - d.AddNode(fromPod) - - d.AddEdge(Edge{ - from: fromSvc, - to: to, - attributes: map[string]interface{}{ - "test-key": "test-value", - }, - }) - d.AddEdge(Edge{ - from: fromPod, - to: to, - attributes: map[string]interface{}{ - "test-key": "test-value", - }, - }) - return d - }(), - }, - want: []Node{ - { - name: "test-pod", - namespace: "test-namespace", - objType: "pod", - attributes: nil, - }, - { - name: "test-pod2", - namespace: "test-namespace", - objType: "pod", - attributes: nil, - }, - { - name: "test-service", - namespace: "test-namespace", - objType: "service", - attributes: nil, - }, - }, - wantErr: false, - }, - } - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - got, err := tt.fields.d.ListNodes() - if (err != nil) != tt.wantErr { - t.Errorf("Dagger.ListNodes() error = %v, wantErr %v", err, tt.wantErr) - return - } - if !arrayEqualNode(got, tt.want) { - t.Errorf("Dagger.ListNodes() = %v, want %v", got, tt.want) - } - }) - } -} - -func TestDagger_ListNeighbors(t *testing.T) { - type fields struct { - d *Dagger - } - type args struct { - node Node - } - tests := []struct { - name string - fields fields - args args - want []Node - wantErr bool - }{ - { - name: "list two neighbor nodes", - fields: fields{ - d: func() *Dagger { - d := NewDaggerStore() - from := Node{ - name: "test-pod", - namespace: "test-namespace", - objType: "pod", - attributes: nil, - } - toSvc := Node{ - name: "test-service", - namespace: "test-namespace", - objType: "service", - attributes: nil, - } - toPod := Node{ - name: "test-pod2", - namespace: "test-namespace", - objType: "pod", - attributes: nil, - } - d.AddNode(from) - d.AddNode(toSvc) - d.AddNode(toPod) - - d.AddEdge(Edge{ - from: from, - to: toSvc, - attributes: map[string]interface{}{ - "test-key": "test-value", - }, - }) - d.AddEdge(Edge{ - from: from, - to: toPod, - attributes: map[string]interface{}{ - "test-key": "test-value", - }, - }) - return d - }(), - }, - args: args{ - node: Node{ - name: "test-pod", - namespace: "test-namespace", - objType: "pod", - }, - }, - want: []Node{ - { - name: "test-service", - namespace: "test-namespace", - objType: "service", - attributes: nil, - }, - { - name: "test-pod2", - namespace: "test-namespace", - objType: "pod", - attributes: nil, - }, - }, - wantErr: false, - }, - } - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - got, err := tt.fields.d.ListNeighbors(tt.args.node) - if (err != nil) != tt.wantErr { - t.Errorf("Dagger.ListNeighbors() error = %v, wantErr %v", err, tt.wantErr) - return - } - if !arrayEqualNode(got, tt.want) { - t.Errorf("Dagger.ListNeighbors() = %v, want %v", got, tt.want) - } - }) - } -} diff --git a/pkg/store/graph.go b/pkg/store/graph.go deleted file mode 100644 index 6146ef7220..0000000000 --- a/pkg/store/graph.go +++ /dev/null @@ -1,48 +0,0 @@ -// Copyright (c) Microsoft Corporation. -// Licensed under the MIT license. -package store - -type NodeOps interface { - AddNode(node Node) - DelNode(node Node) - GetNodeAttributes(node Node) (map[string]interface{}, error) - GetNodeAttribute(node Node, key string) (interface{}, error) - SetNodeAttributes(node Node, attributes map[string]interface{}) (map[string]interface{}, error) - SetNodeAttribute(node Node, key string, value interface{}) (map[string]interface{}, error) - DelNodeAttribute(node Node, key string) (map[string]interface{}, error) -} - -type EdgeOps interface { - AddEdge(edge Edge) error - DelEdge(edge Edge) - GetEdgeNodes(edge Edge) (Node, Node, error) - GetEdgeAttributes(edge Edge) (map[string]interface{}, error) - GetEdgeAttribute(edge Edge, key string) (interface{}, error) - SetEdgeAttributes(edge Edge, attributes map[string]interface{}) (map[string]interface{}, error) - SetEdgeAttribute(edge Edge, key string, value interface{}) (map[string]interface{}, error) - DelEdgeAttribute(edge Edge, key string) (map[string]interface{}, error) -} - -type GraphOps interface { - ListNodes() ([]Node, error) - ListNeighbors(node Node) ([]Node, error) - ListOutboundEdges(node Node) ([]Edge, error) - ListInboundEdges(node Node) ([]Edge, error) -} - -type GraphStorage interface { - NodeOps - EdgeOps - GraphOps -} - -type Node struct { - objType string - name, namespace string - attributes map[string]interface{} -} - -type Edge struct { - from, to Node - attributes map[string]interface{} -}