Exemple #1
0
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()
			})
		})
	})

}
Exemple #2
0
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)
	})
}