138 lines
3.9 KiB
Go
138 lines
3.9 KiB
Go
// Copyright 2014 The Cayley Authors. All rights reserved.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package memstore
|
|
|
|
import (
|
|
"sort"
|
|
"testing"
|
|
|
|
. "github.com/smartystreets/goconvey/convey"
|
|
|
|
"github.com/google/cayley/graph"
|
|
)
|
|
|
|
func TestMemstore(t *testing.T) {
|
|
Convey("With a simple memstore", t, func() {
|
|
ts := MakeTestingMemstore()
|
|
Convey("It should have a reasonable size", func() {
|
|
So(ts.Size(), ShouldEqual, 11)
|
|
})
|
|
Convey("It should have an Id Space that makes sense", func() {
|
|
v := ts.GetIdFor("C")
|
|
So(v.(int64), ShouldEqual, 4)
|
|
})
|
|
})
|
|
}
|
|
|
|
func TestIteratorsAndNextResultOrderA(t *testing.T) {
|
|
ts := MakeTestingMemstore()
|
|
fixed := ts.MakeFixed()
|
|
fixed.AddValue(ts.GetIdFor("C"))
|
|
all := ts.GetNodesAllIterator()
|
|
lto := graph.NewLinksToIterator(ts, all, "o")
|
|
innerAnd := graph.NewAndIterator()
|
|
|
|
fixed2 := ts.MakeFixed()
|
|
fixed2.AddValue(ts.GetIdFor("follows"))
|
|
lto2 := graph.NewLinksToIterator(ts, fixed2, "p")
|
|
innerAnd.AddSubIterator(lto2)
|
|
innerAnd.AddSubIterator(lto)
|
|
hasa := graph.NewHasaIterator(ts, innerAnd, "s")
|
|
outerAnd := graph.NewAndIterator()
|
|
outerAnd.AddSubIterator(fixed)
|
|
outerAnd.AddSubIterator(hasa)
|
|
val, ok := outerAnd.Next()
|
|
if !ok {
|
|
t.Error("Expected one matching subtree")
|
|
}
|
|
if ts.GetNameFor(val) != "C" {
|
|
t.Errorf("Matching subtree should be %s, got %s", "barak", ts.GetNameFor(val))
|
|
}
|
|
expected := make([]string, 2)
|
|
expected[0] = "B"
|
|
expected[1] = "D"
|
|
actualOut := make([]string, 2)
|
|
actualOut[0] = ts.GetNameFor(all.LastResult())
|
|
nresultOk := outerAnd.NextResult()
|
|
if !nresultOk {
|
|
t.Error("Expected two results got one")
|
|
}
|
|
actualOut[1] = ts.GetNameFor(all.LastResult())
|
|
nresultOk = outerAnd.NextResult()
|
|
if nresultOk {
|
|
t.Error("Expected two results got three")
|
|
}
|
|
CompareStringSlices(t, expected, actualOut)
|
|
val, ok = outerAnd.Next()
|
|
if ok {
|
|
t.Error("More than one possible top level output?")
|
|
}
|
|
}
|
|
|
|
func CompareStringSlices(t *testing.T, expected []string, actual []string) {
|
|
if len(expected) != len(actual) {
|
|
t.Error("String slices are not the same length")
|
|
}
|
|
sort.Strings(expected)
|
|
sort.Strings(actual)
|
|
for i := 0; i < len(expected); i++ {
|
|
if expected[i] != actual[i] {
|
|
t.Errorf("At index %d, expected \"%s\" and got \"%s\"", i, expected[i], actual[i])
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestLinksToOptimization(t *testing.T) {
|
|
ts := MakeTestingMemstore()
|
|
fixed := ts.MakeFixed()
|
|
fixed.AddValue(ts.GetIdFor("cool"))
|
|
lto := graph.NewLinksToIterator(ts, fixed, "o")
|
|
lto.AddTag("foo")
|
|
newIt, changed := lto.Optimize()
|
|
if !changed {
|
|
t.Error("Iterator didn't change")
|
|
}
|
|
if newIt.Type() != "llrb" {
|
|
t.Fatal("Didn't swap out to LLRB")
|
|
}
|
|
v := newIt.(*LlrbIterator)
|
|
v_clone := v.Clone()
|
|
if v_clone.DebugString(0) != v.DebugString(0) {
|
|
t.Fatal("Wrong iterator. Got ", v_clone.DebugString(0))
|
|
}
|
|
if len(v_clone.Tags()) < 1 || v_clone.Tags()[0] != "foo" {
|
|
t.Fatal("Tag on LinksTo did not persist")
|
|
}
|
|
}
|
|
|
|
func TestRemoveTriple(t *testing.T) {
|
|
ts := MakeTestingMemstore()
|
|
ts.RemoveTriple(graph.MakeTriple("E", "follows", "F", ""))
|
|
fixed := ts.MakeFixed()
|
|
fixed.AddValue(ts.GetIdFor("E"))
|
|
lto := graph.NewLinksToIterator(ts, fixed, "s")
|
|
fixed2 := ts.MakeFixed()
|
|
fixed2.AddValue(ts.GetIdFor("follows"))
|
|
lto2 := graph.NewLinksToIterator(ts, fixed2, "p")
|
|
innerAnd := graph.NewAndIterator()
|
|
innerAnd.AddSubIterator(lto2)
|
|
innerAnd.AddSubIterator(lto)
|
|
hasa := graph.NewHasaIterator(ts, innerAnd, "o")
|
|
newIt, _ := hasa.Optimize()
|
|
_, ok := newIt.Next()
|
|
if ok {
|
|
t.Error("E should not have any followers.")
|
|
}
|
|
}
|