/* * EliasDB * * Copyright 2016 Matthias Ladkau. All rights reserved. * * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ package graph import ( "errors" "fmt" "strings" "testing" "devt.de/krotik/eliasdb/graph/data" "devt.de/krotik/eliasdb/graph/graphstorage" "devt.de/krotik/eliasdb/graph/util" "devt.de/krotik/eliasdb/hash" "devt.de/krotik/eliasdb/storage" ) func TestSimpleGraphStorage(t *testing.T) { if !RunDiskStorageTests { return } dgs, err := graphstorage.NewDiskGraphStorage(GraphManagerTestDBDir3, false) if err != nil { t.Error(err) return } gm := newGraphManagerNoRules(dgs) node1 := data.NewGraphNode() node1.SetAttr("key", "123") node1.SetAttr("kind", "mykind") node1.SetAttr("Name", "Node1") gm.StoreNode("main", node1) node2 := data.NewGraphNode() node2.SetAttr("key", "456") node2.SetAttr("kind", "mykind") node2.SetAttr("Name", "Node2") gm.StoreNode("main", node2) node3 := data.NewGraphNode() node3.SetAttr("key", "789") node3.SetAttr("kind", "mykind") node3.SetAttr("Name", "Node3") gm.StoreNode("main", node3) edge := data.NewGraphEdge() edge.SetAttr("key", "abc") edge.SetAttr("kind", "myedge") edge.SetAttr(data.EdgeEnd1Key, node1.Key()) edge.SetAttr(data.EdgeEnd1Kind, node1.Kind()) edge.SetAttr(data.EdgeEnd1Role, "node1") edge.SetAttr(data.EdgeEnd1Cascading, true) edge.SetAttr(data.EdgeEnd2Key, node2.Key()) edge.SetAttr(data.EdgeEnd2Kind, node2.Kind()) edge.SetAttr(data.EdgeEnd2Role, "node2") edge.SetAttr(data.EdgeEnd2Cascading, false) err = gm.StoreEdge("main", edge) if err != nil { t.Error(err) } if gm.EdgeCount("myedge") != 1 { t.Error("Unexpected edge count") return } // Check that the correct data has been written edgeTree, _ := gm.getEdgeStorageHTree("main", "myedge", false) keyAttrs := PrefixNSAttrs + edge.Key() val, err := edgeTree.Get([]byte(keyAttrs)) if err != nil || val == nil { t.Error("Unexpected result:", val, val) return } if res := len(val.([]string)); res != 8 { t.Error("Unexpected number of stored attributes:", res) } keyAttr := PrefixNSAttr + edge.Key() + gm.nm.Encode32(data.EdgeEnd2Key, false) if val, err := edgeTree.Get([]byte(keyAttr)); err != nil || val != node2.Key() { t.Error("Unexpected result:", err, val) return } _, nodeTree, _ := gm.getNodeStorageHTree("main", "mykind", false) specMap, err := nodeTree.Get([]byte(PrefixNSSpecs + node2.Key())) if err != nil || specMap == nil { t.Error("Unexpected result:", specMap, err) } if len(specMap.(map[string]string)) != 1 { t.Error("Unexpected size of spec map") return } if _, ok := specMap.(map[string]string)[gm.nm.Encode16(edge.End2Role(), false)+gm.nm.Encode16(edge.Kind(), false)+ gm.nm.Encode16(edge.End1Role(), false)+gm.nm.Encode16(edge.End1Kind(), false)]; !ok { t.Error("Unexpected content of spec map") return } fetchedEdge, err := gm.FetchEdge("main", edge.Key(), edge.Kind()) if err != nil { t.Error(err) return } if !data.NodeCompare(edge, fetchedEdge, nil) { t.Error("Fetched edge should contain the same data as the stored edge") return } // Try to change one of the endpoints edge.SetAttr(data.EdgeEnd1Key, node3.Key()) err = gm.StoreEdge("main", edge) if err.Error() != "GraphError: Invalid data (Cannot update endpoints or spec of existing edge: abc)" { t.Error(err) return } // Try again to make sure it was not updated edge.SetAttr(data.EdgeEnd1Key, node3.Key()) err = gm.StoreEdge("main", edge) if err.Error() != "GraphError: Invalid data (Cannot update endpoints or spec of existing edge: abc)" { t.Error(err) } edge.SetAttr(data.EdgeEnd1Key, node1.Key()) edge.SetAttr("Name", "Test") err = gm.StoreEdge("main", edge) if err != nil { t.Error(err) return } fetchedEdge, err = gm.FetchEdge("main", edge.Key(), edge.Kind()) if err != nil { t.Error(err) return } if fetchedEdge.Attr("Name") != "Test" { t.Error("Unexpected attribute value") return } if gm.EdgeCount("myedge") != 1 { t.Error("Unexpected edge count") return } // Store more edges edge2 := data.NewGraphEdge() edge2.SetAttr("key", "def") edge2.SetAttr("kind", "myedge") edge2.SetAttr(data.EdgeEnd1Key, node1.Key()) edge2.SetAttr(data.EdgeEnd1Kind, node1.Kind()) edge2.SetAttr(data.EdgeEnd1Role, "node1") edge2.SetAttr(data.EdgeEnd1Cascading, true) edge2.SetAttr(data.EdgeEnd2Key, node3.Key()) edge2.SetAttr(data.EdgeEnd2Kind, node3.Kind()) edge2.SetAttr(data.EdgeEnd2Role, "node2") edge2.SetAttr(data.EdgeEnd2Cascading, false) err = gm.StoreEdge("main", edge2) if err != nil { t.Error(err) return } // Spec map has still one entry specMap, err = nodeTree.Get([]byte(PrefixNSSpecs + node1.Key())) if err != nil || specMap == nil { t.Error("Unexpected result:", specMap, err) } if len(specMap.(map[string]string)) != 1 { t.Error("Unexpected size of spec map") return } if gm.EdgeCount("myedge") != 2 { t.Error("Unexpected edge count") return } edge2.SetAttr("key", "ghi") err = gm.StoreEdge("main", edge2) if err != nil { t.Error(err) return } specMap, err = nodeTree.Get([]byte(PrefixNSSpecs + node1.Key())) if err != nil || specMap == nil { t.Error("Unexpected result:", specMap, err) } spec1 := gm.nm.Encode16(edge.End1Role(), true) + gm.nm.Encode16(edge.Kind(), true) + gm.nm.Encode16(edge.End2Role(), true) + gm.nm.Encode16(edge.End2Kind(), true) edgeInfo1Key := PrefixNSEdge + edge.End1Key() + spec1 obj, err := nodeTree.Get([]byte(edgeInfo1Key)) targetMap := obj.(map[string]*edgeTargetInfo) // There should be 3 entries in the target map at this point if len(targetMap) != 3 { t.Error("Unexpected size of target map") return } testInfo := targetMap["def"] if !testInfo.CascadeToTarget { t.Error("Edge should cascade to target from end1") return } if testInfo.TargetNodeKey != node3.Key() { t.Error("Edge should go to node3") return } if testInfo.TargetNodeKind != node3.Kind() { t.Error("Edge should go to node3") return } if len(specMap.(map[string]string)) != 1 { t.Error("Unexpected size of spec map") return } // At this point there are 3 relationships in the db: // node1 -> node2 [abc] // node1 -> node3 [def] // node1 -> node3 [ghi] if gm.EdgeCount("myedge") != 3 { t.Error("Unexpected edge count") return } // Test index lookup iq, _ := gm.EdgeIndexQuery("main", "myedge") res, _ := iq.LookupValue("Name", "test") if fmt.Sprint(res) != "["+edge.Key()+"]" { t.Error("Unexpected result:", res) return } // Test removal removedEdge, err := gm.RemoveEdge("main", edge.Key(), edge.Kind()) if !data.NodeCompare(edge, removedEdge, nil) { t.Error("Unexpected result") return } if gm.EdgeCount("myedge") != 2 { t.Error("Unexpected edge count") return } // Check that the correct data has been removed edgeTree, _ = gm.getEdgeStorageHTree("main", "myedge", false) keyAttrs = PrefixNSAttrs + edge.Key() val, err = edgeTree.Get([]byte(keyAttrs)) if err != nil || val != nil { t.Error("Unexpected result:", val, val) return } // Check that the spec entry is still there specMap, err = nodeTree.Get([]byte(PrefixNSSpecs + node1.Key())) if err != nil || specMap == nil { t.Error("Unexpected result:", specMap, err) return } if len(specMap.(map[string]string)) != 1 { t.Error("Unexpected size of spec map") return } obj, err = nodeTree.Get([]byte(edgeInfo1Key)) targetMap = obj.(map[string]*edgeTargetInfo) // There should be 2 entries in the target map at this point if len(targetMap) != 2 { t.Error("Unexpected size of target map") return } removedEdge, err = gm.RemoveEdge("main", edge2.Key(), edge2.Kind()) if !data.NodeCompare(edge2, removedEdge, nil) { t.Error("Unexpected result") return } if gm.EdgeCount("myedge") != 1 { t.Error("Unexpected edge count") return } // Check that the spec entry is still there specMap, err = nodeTree.Get([]byte(PrefixNSSpecs + node1.Key())) if err != nil || specMap == nil { t.Error("Unexpected result:", specMap, err) return } if len(specMap.(map[string]string)) != 1 { t.Error("Unexpected size of spec map") return } specMap, err = nodeTree.Get([]byte(PrefixNSSpecs + node3.Key())) if err != nil || specMap == nil { t.Error("Unexpected result:", specMap, err) return } if len(specMap.(map[string]string)) != 1 { t.Error("Unexpected size of spec map") return } obj, err = nodeTree.Get([]byte(edgeInfo1Key)) targetMap = obj.(map[string]*edgeTargetInfo) // There should be 1 entries in the target map at this point if len(targetMap) != 1 { t.Error("Unexpected size of target map") return } edge2.SetAttr(data.NodeKey, "def") removedEdge, err = gm.RemoveEdge("main", edge2.Key(), edge2.Kind()) if !data.NodeCompare(edge2, removedEdge, nil) { t.Error("Unexpected result") return } if gm.EdgeCount("myedge") != 0 { t.Error("Unexpected edge count") return } // Check that the spec entry has been removed specMap, err = nodeTree.Get([]byte(PrefixNSSpecs + node1.Key())) if err != nil || specMap != nil { t.Error("Unexpected result:", specMap, err) return } specMap, err = nodeTree.Get([]byte(PrefixNSSpecs + node2.Key())) if err != nil || specMap != nil { t.Error("Unexpected result:", specMap, err) return } specMap, err = nodeTree.Get([]byte(PrefixNSSpecs + node3.Key())) if err != nil || specMap != nil { t.Error("Unexpected result:", specMap, err) return } // Check that the target map has been removed obj, err = nodeTree.Get([]byte(edgeInfo1Key)) if err != nil || obj != nil { t.Error("Unexpected result:", specMap, err) return } it := hash.NewHTreeIterator(edgeTree) if it.HasNext() { t.Error("Tree iterator should find no elements in the tree") return } dgs.Close() } func TestSimpleGraphStorageErrorCases(t *testing.T) { node1 := data.NewGraphNode() node1.SetAttr("key", "123") node1.SetAttr("kind", "mykind") node1.SetAttr("Name", "Node1") node2 := data.NewGraphNode() node2.SetAttr("key", "456") node2.SetAttr("kind", "mynewkind") node2.SetAttr("Name", "Node2") // Creeate storage and insert test nodes mgs := graphstorage.NewMemoryGraphStorage("mystorage") gm := newGraphManagerNoRules(mgs) gm.StoreNode("main", node1) gm.StoreNode("main", node2) edge := data.NewGraphEdge() edge.SetAttr("key", "abc") edge.SetAttr("kind", "myedge") edge.SetAttr(data.EdgeEnd1Key, node1.Key()) edge.SetAttr(data.EdgeEnd1Kind, node1.Kind()) edge.SetAttr(data.EdgeEnd1Role, "node1-") edge.SetAttr(data.EdgeEnd1Cascading, true) edge.SetAttr(data.EdgeEnd2Key, node2.Key()) edge.SetAttr(data.EdgeEnd2Kind, "xxx") edge.SetAttr(data.EdgeEnd2Role, "node2-") edge.SetAttr(data.NodeName, "Edge name") _, _, err := gm.Traverse("main", node1.Key(), node2.Kind(), "abc", false) if err.Error() != "GraphError: Invalid data (Invalid spec: abc)" { t.Error("Unexpected store result:", err) return } _, _, err = gm.Traverse("main", node1.Key(), node2.Kind(), ":::abc", false) if err.Error() != "GraphError: Invalid data (Invalid spec: :::abc - spec needs to be fully specified for direct traversal)" { t.Error("Unexpected store result:", err) return } _, _, err = gm.TraverseMulti("main", node1.Key(), node2.Kind(), "abc", false) if err.Error() != "GraphError: Invalid data (Invalid spec: abc)" { t.Error("Unexpected store result:", err) return } if err := gm.StoreEdge("main", edge); err.Error() != "GraphError: Invalid data (Edge role node1- is not alphanumeric - can only contain [a-zA-Z0-9_])" { t.Error("Unexpected store result:", err) return } edge.SetAttr(data.EdgeEnd1Role, "node1") if err := gm.StoreEdge("main", edge); err.Error() != "GraphError: Invalid data (Edge role node2- is not alphanumeric - can only contain [a-zA-Z0-9_])" { t.Error("Unexpected store result:", err) return } edge.SetAttr(data.EdgeEnd2Role, "node2") if err := gm.StoreEdge("main", edge); err.Error() != "GraphError: Invalid data (Edge is missing a cascading value for end2)" { t.Error("Unexpected store result:", err) return } edge.SetAttr(data.EdgeEnd2Cascading, false) if err := gm.StoreEdge("main", edge); err.Error() != "GraphError: Invalid data (Can't store edge to non-existend node kind: xxx)" { t.Error("Unexpected store result:", err) return } edge.SetAttr(data.EdgeEnd2Kind, node2.Kind()) edge.SetAttr(data.EdgeEnd1Kind, "xxx") if err := gm.StoreEdge("main", edge); err.Error() != "GraphError: Invalid data (Can't store edge to non-existend node kind: xxx)" { t.Error("Unexpected store result:", err) return } edge.SetAttr(data.EdgeEnd1Kind, node1.Kind()) edge.SetAttr(data.EdgeEnd1Key, "xxx") if err := gm.StoreEdge("main", edge); err.Error() != "GraphError: Invalid data (Can't find edge endpoint: xxx (mykind))" { t.Error("Unexpected store result:", err) return } edge.SetAttr(data.EdgeEnd1Key, node1.Key()) edge.SetAttr(data.EdgeEnd2Key, "xxx") if err := gm.StoreEdge("main", edge); err.Error() != "GraphError: Invalid data (Can't find edge endpoint: xxx (mynewkind))" { t.Error("Unexpected store result:", err) return } edge.SetAttr(data.EdgeEnd2Key, node2.Key()) // Test storage access failures sm := gm.gs.StorageManager("main"+"myedge"+StorageSuffixEdgesIndex, false) sm.(*storage.MemoryStorageManager).AccessMap[1] = storage.AccessCacheAndFetchError if err := gm.StoreEdge("main", edge); err == nil { t.Error("Unexpected store result:", err) return } if _, err := gm.RemoveEdge("main", edge.Key(), edge.Kind()); err == nil { t.Error("Unexpected store result:", err) return } delete(sm.(*storage.MemoryStorageManager).AccessMap, 1) sm.(*storage.MemoryStorageManager).AccessMap[2] = storage.AccessInsertError if err := gm.StoreEdge("main", edge); err == nil { t.Error("Unexpected store result:", err) return } delete(sm.(*storage.MemoryStorageManager).AccessMap, 2) // Reset storage and insert test nodes mgs = graphstorage.NewMemoryGraphStorage("mystorage") gm = newGraphManagerNoRules(mgs) gm.StoreNode("main", node1) gm.StoreNode("main", node2) // Test high level errors sm = gm.gs.StorageManager("main"+"mykind"+StorageSuffixNodes, false) sm.(*storage.MemoryStorageManager).AccessMap[1] = storage.AccessCacheAndFetchError if err := gm.StoreEdge("main", edge); err == nil { t.Error("Unexpected store result:", err) return } if _, _, err := gm.Traverse("main", "bla", "mykind", "", false); err == nil { t.Error("Unexpected store result:", err) return } delete(sm.(*storage.MemoryStorageManager).AccessMap, 1) sm = gm.gs.StorageManager("main"+"myedge"+StorageSuffixEdges, false) sm.(*storage.MemoryStorageManager).AccessMap[1] = storage.AccessCacheAndFetchError if _, err := gm.RemoveEdge("main", edge.Key(), edge.Kind()); err == nil { t.Error("Unexpected store result:", err) return } if _, err := gm.FetchEdge("main", edge.Key(), edge.Kind()); err == nil { t.Error("Unexpected store result:", err) return } delete(sm.(*storage.MemoryStorageManager).AccessMap, 1) sm = gm.gs.StorageManager("main"+"mynewkind"+StorageSuffixNodes, false) sm.(*storage.MemoryStorageManager).AccessMap[1] = storage.AccessCacheAndFetchError if err := gm.StoreEdge("main", edge); err == nil { t.Error("Unexpected store result:", err) return } delete(sm.(*storage.MemoryStorageManager).AccessMap, 1) graphstorage.MgsRetFlushMain = &util.GraphError{Type: util.ErrFlushing, Detail: errors.New("Test").Error()} if err := gm.StoreEdge("main", edge); err == nil { t.Error("Unexpected store result:", err) return } if _, err := gm.RemoveEdge("main", edge.Key(), edge.Kind()); err == nil { t.Error("Unexpected store result:", err) return } graphstorage.MgsRetFlushMain = nil // Finally insert the edge if err := gm.StoreEdge("main", edge); err != nil { t.Error("Unexpected store result:", err) return } sm = gm.gs.StorageManager("main"+"myedge"+StorageSuffixEdges, false) sm.(*storage.MemoryStorageManager).AccessMap[1] = storage.AccessCacheAndFetchError traverseSpec := edge.End2Role() + ":" + edge.Kind() + ":" + edge.End1Role() + ":" + edge.End1Kind() _, _, err = gm.Traverse("main", edge.End2Key(), edge.End2Kind(), traverseSpec, true) if !strings.Contains(err.Error(), "Slot not found") { t.Error("Unexpected store result:", err) return } delete(sm.(*storage.MemoryStorageManager).AccessMap, 1) sm = gm.gs.StorageManager("main"+"myedge"+StorageSuffixEdgesIndex, false) sm.(*storage.MemoryStorageManager).AccessMap[5] = storage.AccessInsertError edge.SetAttr("name", "New edge name") if err := gm.StoreEdge("main", edge); err == nil { t.Error("Unexpected store result:", err) return } delete(sm.(*storage.MemoryStorageManager).AccessMap, 5) resetStorage := func() { mgs = graphstorage.NewMemoryGraphStorage("mystorage") gm = newGraphManagerNoRules(mgs) gm.StoreNode("main", node1) gm.StoreNode("main", node2) gm.StoreEdge("main", edge) } // Test low level errors spec1 := gm.nm.Encode16(edge.End1Role(), true) + gm.nm.Encode16(edge.Kind(), true) + gm.nm.Encode16(edge.End2Role(), true) + gm.nm.Encode16(edge.End2Kind(), true) spec2 := gm.nm.Encode16(edge.End2Role(), true) + gm.nm.Encode16(edge.Kind(), true) + gm.nm.Encode16(edge.End1Role(), true) + gm.nm.Encode16(edge.End1Kind(), true) specsNode1Key := PrefixNSSpecs + edge.End1Key() edgeInfo1Key := PrefixNSEdge + edge.End1Key() + spec1 specsNode2Key := PrefixNSSpecs + edge.End2Key() edgeInfo2Key := PrefixNSEdge + edge.End2Key() + spec2 resetStorage() // Test error case of index lookup sm = gm.gs.StorageManager("main"+edge.Kind()+StorageSuffixEdgesIndex, false) sm.(*storage.MemoryStorageManager).AccessMap[1] = storage.AccessCacheAndFetchError if _, err := gm.EdgeIndexQuery("main", "myedge"); err == nil { t.Error(err) return } delete(sm.(*storage.MemoryStorageManager).AccessMap, 1) _, nodeTree, _ := gm.getNodeStorageHTree("main", edge.End2Kind(), false) _, loc, _ := nodeTree.GetValueAndLocation([]byte(specsNode2Key)) sm = gm.gs.StorageManager("main"+edge.End2Kind()+StorageSuffixNodes, false) sm.(*storage.MemoryStorageManager).AccessMap[loc] = storage.AccessCacheAndFetchError if _, err := gm.RemoveEdge("main", edge.Key(), edge.Kind()); !strings.Contains(err.Error(), "Slot not found") { t.Error("Unexpected store result:", err) return } if err := gm.StoreEdge("main", edge); !strings.Contains(err.Error(), "Slot not found") { t.Error("Unexpected store result:", err) return } delete(sm.(*storage.MemoryStorageManager).AccessMap, loc) resetStorage() _, nodeTree, _ = gm.getNodeStorageHTree("main", edge.End1Kind(), false) _, _ = nodeTree.Remove([]byte(specsNode1Key)) if _, err := gm.RemoveEdge("main", edge.Key(), edge.Kind()); !strings.Contains(err.Error(), "Expected spec entry is missing") { t.Error("Unexpected store result:", err) return } resetStorage() _, nodeTree, _ = gm.getNodeStorageHTree("main", edge.End2Kind(), false) _, loc, _ = nodeTree.GetValueAndLocation([]byte(specsNode2Key)) sm = gm.gs.StorageManager("main"+edge.End2Kind()+StorageSuffixNodes, false) sm.(*storage.MemoryStorageManager).AccessMap[loc] = storage.AccessFreeError if _, err := gm.RemoveEdge("main", edge.Key(), edge.Kind()); !strings.Contains(err.Error(), "Slot not found") { t.Error("Unexpected store result:", err) return } delete(sm.(*storage.MemoryStorageManager).AccessMap, loc) resetStorage() _, nodeTree, _ = gm.getNodeStorageHTree("main", edge.End1Kind(), false) val, loc, _ := nodeTree.GetValueAndLocation([]byte(specsNode1Key)) val.(map[string]string)["test2"] = "test3" sm = gm.gs.StorageManager("main"+edge.End1Kind()+StorageSuffixNodes, false) sm.(*storage.MemoryStorageManager).AccessMap[loc] = storage.AccessUpdateError if _, err := gm.RemoveEdge("main", edge.Key(), edge.Kind()); !strings.Contains(err.Error(), "Slot not found") { t.Error("Unexpected store result:", err) return } if err := gm.StoreEdge("main", edge); !strings.Contains(err.Error(), "Slot not found") { t.Error("Unexpected store result:", err) return } delete(sm.(*storage.MemoryStorageManager).AccessMap, loc) resetStorage() _, nodeTree, _ = gm.getNodeStorageHTree("main", edge.End2Kind(), false) _, loc, _ = nodeTree.GetValueAndLocation([]byte(edgeInfo2Key)) sm = gm.gs.StorageManager("main"+edge.End2Kind()+StorageSuffixNodes, false) sm.(*storage.MemoryStorageManager).AccessMap[loc] = storage.AccessCacheAndFetchError if _, err := gm.RemoveEdge("main", edge.Key(), edge.Kind()); !strings.Contains(err.Error(), "Slot not found") { t.Error("Unexpected store result:", err) return } if err := gm.StoreEdge("main", edge); !strings.Contains(err.Error(), "Slot not found") { t.Error("Unexpected store result:", err) return } traverseSpec = edge.End2Role() + ":" + edge.Kind() + ":" + edge.End1Role() + ":" + edge.End1Kind() _, _, err = gm.Traverse("main", edge.End2Key(), edge.End2Kind(), traverseSpec, false) if !strings.Contains(err.Error(), "Slot not found") { t.Error("Unexpected store result:", err) return } traverseSpec = ":" + edge.Kind() + ":" + edge.End1Role() + ":" + edge.End1Kind() _, _, err = gm.TraverseMulti("main", edge.End2Key(), edge.End2Kind(), traverseSpec, false) if !strings.Contains(err.Error(), "Slot not found") { t.Error("Unexpected store result:", err) return } delete(sm.(*storage.MemoryStorageManager).AccessMap, loc) resetStorage() _, nodeTree, _ = gm.getNodeStorageHTree("main", edge.End1Kind(), false) _, _ = nodeTree.Remove([]byte(edgeInfo1Key)) if _, err := gm.RemoveEdge("main", edge.Key(), edge.Kind()); !strings.Contains(err.Error(), "Expected edgeTargetInfo entry is missing") { t.Error("Unexpected store result:", err) return } resetStorage() _, nodeTree, _ = gm.getNodeStorageHTree("main", edge.End2Kind(), false) _, loc, _ = nodeTree.GetValueAndLocation([]byte(edgeInfo2Key)) sm = gm.gs.StorageManager("main"+edge.End2Kind()+StorageSuffixNodes, false) sm.(*storage.MemoryStorageManager).AccessMap[loc] = storage.AccessFreeError if _, err := gm.RemoveEdge("main", edge.Key(), edge.Kind()); !strings.Contains(err.Error(), "Slot not found") { t.Error("Unexpected store result:", err) return } delete(sm.(*storage.MemoryStorageManager).AccessMap, loc) resetStorage() nodeattTree, nodeTree, _ := gm.getNodeStorageHTree("main", edge.End1Kind(), false) val, loc, _ = nodeTree.GetValueAndLocation([]byte(edgeInfo1Key)) val.(map[string]*edgeTargetInfo)["test2"] = nil sm = gm.gs.StorageManager("main"+edge.End1Kind()+StorageSuffixNodes, false) sm.(*storage.MemoryStorageManager).AccessMap[loc] = storage.AccessUpdateError if _, err := gm.RemoveEdge("main", edge.Key(), edge.Kind()); !strings.Contains(err.Error(), "Slot not found") { t.Error("Unexpected store result:", err) return } if err := gm.StoreEdge("main", edge); !strings.Contains(err.Error(), "Slot not found") { t.Error("Unexpected store result:", err) return } delete(sm.(*storage.MemoryStorageManager).AccessMap, loc) _, loc, _ = nodeattTree.GetValueAndLocation([]byte(PrefixNSAttrs + edge.End1Key())) sm.(*storage.MemoryStorageManager).AccessMap[loc] = storage.AccessCacheAndFetchError traverseSpec = edge.End2Role() + ":" + edge.Kind() + ":" + edge.End1Role() + ":" + edge.End1Kind() _, _, err = gm.Traverse("main", edge.End2Key(), edge.End2Kind(), traverseSpec, true) if !strings.Contains(err.Error(), "Slot not found") { t.Error("Unexpected store result:", err) return } delete(sm.(*storage.MemoryStorageManager).AccessMap, loc) mgs = graphstorage.NewMemoryGraphStorage("mystorage") gm = newGraphManagerNoRules(mgs) gm.StoreNode("main", node1) gm.StoreNode("main", node2) sm = gm.gs.StorageManager("main"+edge.Kind()+StorageSuffixEdges, true) sm.(*storage.MemoryStorageManager).AccessMap[11] = storage.AccessInsertError if err := gm.StoreEdge("main", edge); !strings.Contains(err.Error(), "Could not write graph information") { t.Error("Unexpected store result:", err) return } delete(sm.(*storage.MemoryStorageManager).AccessMap, 11) resetStorage() sm = gm.gs.StorageManager("main"+edge.Kind()+StorageSuffixEdges, false) sm.(*storage.MemoryStorageManager).AccessMap[11] = storage.AccessCacheAndFetchError traverseSpec = edge.End1Role() + ":" + edge.Kind() + ":" + edge.End2Role() + ":" + edge.End2Kind() _, _, err = gm.Traverse("main", edge.End1Key(), edge.End1Kind(), traverseSpec, true) if !strings.Contains(err.Error(), "Slot not found") { t.Error("Unexpected store result:", err) return } sm.(*storage.MemoryStorageManager).AccessMap[11] = storage.AccessFreeError if _, err := gm.RemoveEdge("main", edge.Key(), edge.Kind()); !strings.Contains(err.Error(), "Could not write graph information") { t.Error("Unexpected store result:", err) return } delete(sm.(*storage.MemoryStorageManager).AccessMap, 11) resetStorage() sm = gm.gs.StorageManager("main"+edge.End1Kind()+StorageSuffixNodes, false) sm.(*storage.MemoryStorageManager).AccessMap[1] = storage.AccessCacheAndFetchError if _, err := gm.RemoveEdge("main", edge.Key(), edge.Kind()); !strings.Contains(err.Error(), "Failed to access graph storage component") { t.Error("Unexpected store result:", err) return } delete(sm.(*storage.MemoryStorageManager).AccessMap, 1) resetStorage() sm = gm.gs.StorageManager("main"+edge.End2Kind()+StorageSuffixNodes, false) sm.(*storage.MemoryStorageManager).AccessMap[1] = storage.AccessCacheAndFetchError traverseSpec = edge.End1Role() + ":" + edge.Kind() + ":" + edge.End2Role() + ":" + edge.End2Kind() _, _, err = gm.Traverse("main", edge.End1Key(), edge.End1Kind(), traverseSpec, true) if !strings.Contains(err.Error(), "Slot not found") { t.Error("Unexpected store result:", err) return } if _, err := gm.RemoveEdge("main", edge.Key(), edge.Kind()); !strings.Contains(err.Error(), "Failed to access graph storage component") { t.Error("Unexpected store result:", err) return } delete(sm.(*storage.MemoryStorageManager).AccessMap, 1) resetStorage() sm = gm.gs.StorageManager("main"+edge.Kind()+StorageSuffixEdgesIndex, false) sm.(*storage.MemoryStorageManager).AccessMap[2] = storage.AccessFreeError if _, err := gm.RemoveEdge("main", edge.Key(), edge.Kind()); !strings.Contains(err.Error(), "Index error") { t.Error("Unexpected store result:", err) return } delete(sm.(*storage.MemoryStorageManager).AccessMap, 2) // Test removal of non-existing edge resetStorage() if obj, err := gm.RemoveEdge("main", edge.Key(), edge.Kind()); obj == nil || err != nil { t.Error("Unexpected store result:", obj, err) return } if obj, err := gm.RemoveEdge("main", edge.Key(), edge.Kind()); obj != nil || err != nil { t.Error("Unexpected store result:", obj, err) return } } func TestEdgeOperations(t *testing.T) { node1 := data.NewGraphNode() node1.SetAttr("key", "123") node1.SetAttr("kind", "mykind") node1.SetAttr("Name", "Node1") node2 := data.NewGraphNode() node2.SetAttr("key", "456") node2.SetAttr("kind", "mynewkind") node2.SetAttr("Name", "Node2") constructEdge := func(kind string) data.Edge { edge := data.NewGraphEdge() edge.SetAttr("key", "abc") edge.SetAttr("kind", kind) edge.SetAttr(data.EdgeEnd1Key, node1.Key()) edge.SetAttr(data.EdgeEnd1Kind, node1.Kind()) edge.SetAttr(data.EdgeEnd1Role, "node1") edge.SetAttr(data.EdgeEnd1Cascading, true) edge.SetAttr(data.EdgeEnd1CascadingLast, true) edge.SetAttr(data.EdgeEnd2Key, node2.Key()) edge.SetAttr(data.EdgeEnd2Kind, node2.Kind()) edge.SetAttr(data.EdgeEnd2Role, "node2") edge.SetAttr(data.EdgeEnd2Cascading, false) edge.SetAttr(data.NodeName, "Edge "+kind) return edge } // Creeate storage and insert test nodes mgs := graphstorage.NewMemoryGraphStorage("mystorage") gm := newGraphManagerNoRules(mgs) if err := gm.StoreNode("main", node1); err != nil { t.Error(err) } if err := gm.StoreNode("main", node2); err != nil { t.Error(err) } edge1 := constructEdge("myedge") if err := gm.StoreEdge("main", edge1); err != nil { t.Error(err) } edge2 := constructEdge("myotheredge") if err := gm.StoreEdge("main", edge2); err != nil { t.Error(err) } specs, err := gm.FetchNodeEdgeSpecs("main", node1.Key(), node1.Kind()) if err != nil { t.Error(err) return } if fmt.Sprint(specs) != "[node1:myedge:node2:mynewkind node1:myotheredge:node2:mynewkind]" { t.Error("Unexpected specs result:", specs) return } sm := gm.gs.StorageManager("main"+node1.Kind()+StorageSuffixNodes, false) sm.(*storage.MemoryStorageManager).AccessMap[1] = storage.AccessCacheAndFetchError _, err = gm.FetchNodeEdgeSpecs("main", node1.Key(), node1.Kind()) if err.Error() != "GraphError: Failed to access graph storage component (Slot not found (mystorage/mainmykind.nodes - Location:1))" { t.Error("Unexpected error:", err) return } _, _, err = gm.TraverseMulti("main", node1.Key(), node1.Kind(), ":::", false) if err.Error() != "GraphError: Failed to access graph storage component (Slot not found (mystorage/mainmykind.nodes - Location:1))" { t.Error("Unexpected error:", err) return } delete(sm.(*storage.MemoryStorageManager).AccessMap, 1) _, tree, _ := gm.getNodeStorageHTree("main", node1.Kind(), false) _, loc, _ := tree.GetValueAndLocation([]byte(PrefixNSSpecs + node1.Key())) sm.(*storage.MemoryStorageManager).AccessMap[loc] = storage.AccessCacheAndFetchError _, err = gm.FetchNodeEdgeSpecs("main", node1.Key(), node1.Kind()) if !strings.Contains(err.Error(), "Slot not found") { t.Error("Unexpected error:", err) return } delete(sm.(*storage.MemoryStorageManager).AccessMap, loc) nodes, edges, err := gm.TraverseMulti("main", node1.Key(), node1.Kind(), "node1:myotheredge:node2:mynewkind", false) if err != nil { t.Error(err) return } if len(nodes) != 1 || len(edges) != 1 { t.Error("Unexpected result:", nodes, edges) return } if !data.NodeCompare(edges[0], edge2, []string{data.NodeKey, data.NodeKind, data.EdgeEnd1Key, data.EdgeEnd1Kind, data.EdgeEnd1Role, data.EdgeEnd1Cascading, data.EdgeEnd2Key, data.EdgeEnd2Kind, data.EdgeEnd2Role, data.EdgeEnd2Cascading}) { t.Error("Edges should match:", edge2, edges[0]) return } if !data.NodeCompare(nodes[0], node2, []string{data.NodeKey, data.NodeKind}) { t.Error("Nodes should match:", node2, nodes[0]) return } // Now lookup from the other side nodes2, edges2, err := gm.Traverse("main", node2.Key(), node2.Kind(), "node2:myotheredge:node1:mykind", false) if err != nil { t.Error(err) return } if len(nodes2) != 1 || len(edges2) != 1 { t.Error("Unexpected result:", nodes2, edges2) return } if !data.NodeCompare(nodes2[0], node1, []string{data.NodeKey, data.NodeKind}) { t.Error("Nodes should match:", node1, nodes2[0]) return } if !data.NodeCompare(edges2[0], edge2, []string{data.NodeKey, data.NodeKind}) { t.Error("Edges should match:", edge2, edges2[0]) return } // Check that the correct ends have been set if edges2[0].End1Key() != node2.Key() { t.Error("Unexpected value in traversed edge") return } else if edges2[0].End1Kind() != node2.Kind() { t.Error("Unexpected value in traversed edge") return } else if edges2[0].End1Role() != "node2" { t.Error("Unexpected value in traversed edge") return } else if edges2[0].End1IsCascading() != false { t.Error("Unexpected value in traversed edge") return } else if edges2[0].End1IsCascadingLast() != false { t.Error("Unexpected value in traversed edge") return } if edges2[0].End2Key() != node1.Key() { t.Error("Unexpected value in traversed edge") return } else if edges2[0].End2Kind() != node1.Kind() { t.Error("Unexpected value in traversed edge") return } else if edges2[0].End2Role() != "node1" { t.Error("Unexpected value in traversed edge") return } else if edges2[0].End2IsCascading() != true { t.Error("Unexpected value in traversed edge") return } else if edges2[0].End2IsCascadingLast() != true { t.Error("Unexpected value in traversed edge") return } // Lookup from the other side getting all attributes nodes2, edges2, err = gm.Traverse("main", node2.Key(), node2.Kind(), "node2:myotheredge:node1:mykind", true) if err != nil { t.Error(err) return } if len(nodes2) != 1 || len(edges2) != 1 { t.Error("Unexpected result:", nodes2, edges2) return } if !data.NodeCompare(nodes2[0], node1, []string{data.NodeKey, data.NodeKind, data.NodeName}) { t.Error("Nodes should match:", node1, nodes2[0]) return } if !data.NodeCompare(edges2[0], edge2, []string{data.NodeKey, data.NodeKind, data.NodeName}) { t.Error("Edges should match:", edge2, edges2[0]) return } // Check that the correct ends have been set if edges2[0].End1Key() != node2.Key() { t.Error("Unexpected value in traversed edge") return } else if edges2[0].End1Kind() != node2.Kind() { t.Error("Unexpected value in traversed edge") return } else if edges2[0].End1Role() != "node2" { t.Error("Unexpected value in traversed edge") return } else if edges2[0].End1IsCascading() != false { t.Error("Unexpected value in traversed edge") return } if edges2[0].End2Key() != node1.Key() { t.Error("Unexpected value in traversed edge") return } else if edges2[0].End2Kind() != node1.Kind() { t.Error("Unexpected value in traversed edge") return } else if edges2[0].End2Role() != "node1" { t.Error("Unexpected value in traversed edge") return } else if edges2[0].End2IsCascading() != true { t.Error("Unexpected value in traversed edge") return } // Lookup from the original side with all attributes nodes, edges, err = gm.Traverse("main", node1.Key(), node1.Kind(), "node1:myotheredge:node2:mynewkind", true) if err != nil { t.Error(err) return } if len(nodes) != 1 || len(edges) != 1 { t.Error("Unexpected result:", nodes, edges) return } if !data.NodeCompare(nodes[0], node2, nil) { t.Error("Nodes should match:", node2, nodes[0]) return } if !data.NodeCompare(edges[0], edge2, nil) { t.Error("Edges should match:", edge2, edges[0]) return } nodes, edges, err = gm.TraverseMulti("main", node1.Key(), node1.Kind(), ":::", false) if err != nil { t.Error(err) return } if len(nodes) != 2 || len(edges) != 2 { t.Error("Unexpected result:", nodes, edges) return } else if nodes[0].Key() != node2.Key() || nodes[1].Key() != node2.Key() { t.Error("Unexpected result:", nodes, edges) return } else if edges[0].Key() != edge1.Key() || edges[1].Key() != edge2.Key() { t.Error("Unexpected result:", nodes, edges) return } nodes, edges, err = gm.TraverseMulti("main", node1.Key(), node1.Kind(), "node1::node2:mynewkind", false) if err != nil { t.Error(err) return } if len(nodes) != 2 || len(edges) != 2 { t.Error("Unexpected result:", nodes, edges) return } else if nodes[0].Key() != node2.Key() || nodes[1].Key() != node2.Key() { t.Error("Unexpected result:", nodes, edges) return } else if edges[0].Key() != edge1.Key() || edges[1].Key() != edge2.Key() { t.Error("Unexpected result:", nodes, edges) return } nodes, edges, err = gm.TraverseMulti("main", node1.Key(), node1.Kind(), "node1:myotheredge::mynewkind", false) if err != nil { t.Error(err) return } if len(nodes) != 1 || len(edges) != 1 { t.Error("Unexpected result:", nodes, edges) return } else if nodes[0].Key() != node2.Key() { t.Error("Unexpected result:", nodes, edges) return } else if edges[0].Key() != edge2.Key() { t.Error("Unexpected result:", nodes, edges) return } nodes, edges, err = gm.TraverseMulti("main", node1.Key(), node1.Kind(), "node2:myotheredge:node2:mynewkind", false) if err != nil { t.Error(err) return } else if len(nodes) != 0 || len(edges) != 0 { t.Error("Unexpected result:", nodes, edges) return } nodes, edges, err = gm.TraverseMulti("main", node1.Key(), node1.Kind(), "node1:myotheredge2:node2:mynewkind", false) if err != nil { t.Error(err) return } else if len(nodes) != 0 || len(edges) != 0 { t.Error("Unexpected result:", nodes, edges) return } nodes, edges, err = gm.TraverseMulti("main", node1.Key(), node1.Kind(), "node1:myotheredge:node3:mynewkind", false) if err != nil { t.Error(err) return } else if len(nodes) != 0 || len(edges) != 0 { t.Error("Unexpected result:", nodes, edges) return } nodes, edges, err = gm.TraverseMulti("main", node1.Key(), node1.Kind(), "node1:myotheredge:node2:mynewkind2", false) if err != nil { t.Error(err) return } else if len(nodes) != 0 || len(edges) != 0 { t.Error("Unexpected result:", nodes, edges) return } }