func TestIterator(t *testing.T) {
var ts *LevelDBTripleStore
Convey("Given a prepared database", t, func() {
tmpDir, _ := ioutil.TempDir(os.TempDir(), "cayley_test")
t.Log(tmpDir)
defer os.RemoveAll(tmpDir)
ok := CreateNewLevelDB(tmpDir)
So(ok, ShouldBeTrue)
ts = NewDefaultLevelDBTripleStore(tmpDir, nil)
ts.AddTripleSet(makeTripleSet())
var it graph.Iterator
Convey("Can create an all iterator for nodes", func() {
it = ts.GetNodesAllIterator()
So(it, ShouldNotBeNil)
Convey("Has basics", func() {
size, accurate := it.Size()
So(size, ShouldBeBetween, 0, 20)
So(accurate, ShouldBeFalse)
So(it.Type(), ShouldEqual, "all")
re_it, ok := it.Optimize()
So(ok, ShouldBeFalse)
So(re_it, ShouldPointTo, it)
})
Convey("Iterates all nodes", func() {
expected := []string{
"A",
"B",
"C",
"D",
"E",
"F",
"G",
"follows",
"status",
"cool",
"status_graph",
}
sort.Strings(expected)
actual := extractValuesFromIterator(ts, it)
sort.Strings(actual)
So(actual, ShouldResemble, expected)
it.Reset()
actual = extractValuesFromIterator(ts, it)
sort.Strings(actual)
So(actual, ShouldResemble, expected)
})
Convey("Contains a couple nodes", func() {
So(it.Check(ts.GetIdFor("A")), ShouldBeTrue)
So(it.Check(ts.GetIdFor("cool")), ShouldBeTrue)
//So(it.Check(ts.GetIdFor("baller")), ShouldBeFalse)
})
Reset(func() {
it.Reset()
})
})
Convey("Can create an all iterator for edges", func() {
it := ts.GetTriplesAllIterator()
So(it, ShouldNotBeNil)
Convey("Has basics", func() {
size, accurate := it.Size()
So(size, ShouldBeBetween, 0, 20)
So(accurate, ShouldBeFalse)
So(it.Type(), ShouldEqual, "all")
re_it, ok := it.Optimize()
So(ok, ShouldBeFalse)
So(re_it, ShouldPointTo, it)
})
Convey("Iterates an edge", func() {
edge_val, _ := it.Next()
triple := ts.GetTriple(edge_val)
set := makeTripleSet()
var string_set []string
for _, t := range set {
string_set = append(string_set, t.ToString())
}
So(triple.ToString(), ShouldBeIn, string_set)
})
Reset(func() {
ts.Close()
})
})
})
}
func TestValue(t *testing.T) {
Convey("steps method", t, func() {
tasks := readBook(".files/1st.yaml")
steps := tasks[0].Series
fmt.Println(tasks[0].Name)
So(steps, ShouldNotBeNil)
So(len(steps), ShouldEqual, 2)
})
Convey("book steps has specific type", t, func() {
tasks := readBook(".files/1st.yaml")
steps := tasks[0].Parallel
So(steps, ShouldNotBeNil)
So(len(steps), ShouldEqual, 0)
})
Convey("walking path produces value", t, func() {
a := make(map[string]interface{})
a["stuff"] = "where"
b := make(map[string]interface{})
b["here"] = a
u := NewValue(b)
u = u.To("here.stuff")
So(u.ToString(), ShouldEqual, "where")
})
Convey("should get the 'here' value from the map", t, func() {
m := make(map[string]string)
m["here"] = "there"
t := NewValue(m)
t = t.Get("here")
So(t.HasValue(), ShouldBeTrue)
So(t.IsMap(), ShouldBeFalse)
So(t.ToString(), ShouldEqual, "there")
})
Convey("using a path to a value that EXISTS should produce that value", t, func() {
m := createMap()
t := NewValue(m)
t = t.Get("here")
So(t.HasValue(), ShouldBeTrue)
So(t.IsMap(), ShouldBeFalse)
So(t.ToInt(), ShouldEqual, 1)
})
Convey("converting with just key", t, func() {
m := make(map[string]string)
m["here"] = "stuff"
h := reflect.ValueOf("here")
actual := reflect.ValueOf(m).MapIndex(h)
val := actual.Interface()
So(val, ShouldEqual, "stuff")
})
Convey("should be true that Value with 1 has a Value and that value is not a map", t, func() {
t := NewValue(1)
So(t.HasValue(), ShouldBeTrue)
So(t.IsMap(), ShouldBeFalse)
})
Convey("should be true that Value with 1 has a Value and that value is not a map", t, func() {
types := []interface{}{
make(map[string]string),
make(map[string]int),
make(map[string]interface{}),
make(map[interface{}]interface{}),
}
for _, k := range types {
t := NewValue(k)
So(t.HasValue(), ShouldBeTrue)
isMap := t.IsMap()
if !isMap {
dumpType(k)
}
So(isMap, ShouldBeTrue)
}
})
Convey("using a path to a value that DOESN'T exist should produce nil value", t, func() {
m := createMap()
t := NewValue(m)
t = t.Get("nope")
So(t.HasValue(), ShouldBeFalse)
So(t.IsMap(), ShouldBeFalse)
})
Convey("a map backed Value should return true for isMap", t, func() {
m := createMap()
t := NewValue(m)
So(t.IsMap(), ShouldBeTrue)
})
Convey("a map backed Value should have a 'value'", t, func() {
m := createMap()
t := NewValue(m)
So(t.values, ShouldNotBeNil)
So(t.HasValue(), ShouldBeTrue)
})
Convey("new value should not have backing value(s)", t, func() {
t := &Value{}
So(t.values, ShouldBeNil)
So(t.HasValue(), ShouldBeFalse)
})
}