Exemple #1
0
func TestCurrentScalarState(t *testing.T) {
	Convey("When commit current message to database", t, func() {
		ev, err := evstore.Dial(mongoURL, "test", "events")
		So(err, ShouldBeNil)
		So(ev, ShouldNotBeNil)

		err = ev.Listenner2().Subscribe2("", Handler)
		So(err, ShouldBeNil)
		//	Loop:
		fmt.Println("All messages read")
		for i := 1; i < 10; i++ {
			timestamp := strconv.FormatInt(time.Now().UnixNano(), 10)
			log.Println(timestamp)
			rand.Seed(time.Now().UTC().UnixNano())
			boxID := strconv.Itoa(rand.Intn(100))
			varID := strconv.Itoa(rand.Intn(200))
			boxID = "1"
			if i > 4 {
				varID = "3"
			} else {
				varID = "4"
			}
			val := strconv.FormatFloat(rand.NormFloat64(), 'f', 2, 64)
			sendMsg := "{\"datestamp\":\"" + timestamp + "\", \"box_id\": " + boxID + ", \"var_id\": " + varID + ", \"value\": " + val + "}"
			err = ev.Committer().SubmitEvent("123", "scalar", sendMsg)
			So(err, ShouldBeNil)
		}
		ev.Close()
	})
}
func TestSubmitEvent(t *testing.T) {
	Convey("Submit simple event", t, func() {
		var (
			results []interface{}
		)
		props := property.Init()
		CleanupCollections()
		ev, err := evstore.Dial(props["mongodb.url"], dbName, "submitevents")
		So(err, ShouldBeNil)
		So(ev, ShouldNotBeNil)
		c := makeStubClient()
		ctx, cancel := context.WithCancel(context.Background())
		defer cancel()
		fromWS, _, _ := c.GetChannels()
		go handleClientRequest(ctx, c, ev)
		m := wsock.MessageT{}
		m["sequenceid"] = ""
		m["tag"] = "test"
		m["event"] = map[string]interface{}{"event": "fake"}
		fromWS <- &m
		<-time.After(time.Millisecond * 100)
		session, err := mgo.Dial(props["mongodb.url"])
		defer session.Close()
		So(err, ShouldBeNil)
		So(session, ShouldNotBeNil)
		iter := session.DB(dbName).C("submitevents").Find(nil).Iter()
		So(iter, ShouldNotBeNil)

		iter.All(&results)
		So(results, ShouldNotBeNil)
		for _, v := range results {
			So(v.(bson.M)["event"].(bson.M)["event"], ShouldEqual, "fake")
		}
	})
}
func TestGetDistanceValueIncorrectPointNumber(t *testing.T) {
	evStore, err := evstore.Dial("localhost", dbName, "test")
	if err != nil {
		t.Fatal(err)
	}
	rpc := NewRPCFunctionInterface(evStore)
	if err != nil {
		t.Fatal(err)
	}
	if rpc == nil {
		t.Fatal("RPCFunctionInterface is nil")
	}
	f, err := rpc.GetFunction("GetDistanceValue")
	if err != nil {
		t.Fatal(err)
	}
	if f == nil {
		t.Fatal("Function is nil")
	}
	tStart := time.Now()
	tStop := tStart.Add(10 * time.Second)
	_, err = f.(func(time.Time, time.Time, int) (chan string, error))(tStart, tStop, -10)
	expectedError := "numberOfPoints should be positive integer"
	if err.Error() != expectedError {
		t.Fatal(err.Error() + " != " + expectedError)
	}

}
func TestGetDistanceValueZerroInterval(t *testing.T) {
	evStore, err := evstore.Dial("localhost", dbName, "test")
	if err != nil {
		t.Fatal(err)
	}
	rpc := NewRPCFunctionInterface(evStore)
	if err != nil {
		t.Fatal(err)
	}
	if rpc == nil {
		t.Fatal("RPCFunctionInterface is nil")
	}
	f, err := rpc.GetFunction("GetDistanceValue")
	if err != nil {
		t.Fatal(err)
	}
	if f == nil {
		t.Fatal("Function is nil")
	}
	tStart := time.Now()
	_, err = f.(func(time.Time, time.Time, int) (chan string, error))(tStart, tStart, 10)
	expectedError := "To must be greater than From"
	if err.Error() != expectedError {
		t.Fatal(err.Error() + " != " + expectedError)
	}

}
func TestListDatabases(t *testing.T) {
	evStore, err := evstore.Dial("localhost", dbName, "test")
	if err != nil {
		t.Fatal(err)
	}
	rpc := NewRPCFunctionInterface(evStore)
	if err != nil {
		t.Fatal(err)
	}
	if rpc == nil {
		t.Fatal("RPCFunctionInterface is nil")
	}
	f, err := rpc.GetFunction("ListDatabases")
	if err != nil {
		t.Fatal(err)
	}
	if f == nil {
		t.Fatal("Function is nil")
	}
	dbList, err := f.(func() ([]string, error))()
	if err != nil {
		t.Fatal(err)
	}
	if len(dbList) == 0 {
		t.Fatal("List should not be empty")
	}
}
func TestEventSrv(t *testing.T) {
	Convey("When commit current message to database", t, func() {
		ev, err := evstore.Dial(mongoURL, dbName, "events")
		So(err, ShouldBeNil)
		So(ev, ShouldNotBeNil)

		err = ev.Listenner2().Subscribe2("", handlerTest)
		So(err, ShouldBeNil)
		ctx := context.WithValue(context.Background(), "test", t)
		ctx, cancel := context.WithCancel(ctx)
		defer cancel()
		go ev.Listenner2().Listen(ctx, "")
		<-time.After(time.Second * 2)

		fmt.Println("All messages read")
		for i := 0; i < 10; i++ {
			timestamp := strconv.FormatInt(time.Now().Unix(), 10)
			log.Println(timestamp)
			rand.Seed(time.Now().UTC().UnixNano())
			boxID := strconv.Itoa(rand.Intn(100))
			varID := strconv.Itoa(rand.Intn(200))
			val := strconv.FormatFloat(rand.NormFloat64(), 'f', 2, 64)
			sendMsg := "{\"datestamp\":\"" + timestamp + "\", \"box_id\": " + boxID + ", \"var_id\": " + varID + ", \"value\": " + val + "}"
			err = ev.Committer().SubmitEvent("123", "scalar", sendMsg)
			So(err, ShouldBeNil)
		}
		<-time.After(time.Second * 3)
		ev.Close()
	})
}
Exemple #7
0
func main() {
	f, err := os.Create("currentsrv.prof")
	if err != nil {
		log.Fatal(err)
	}
	pprof.StartCPUProfile(f)
	defer pprof.StopCPUProfile()
	c := make(chan os.Signal, 1)
	signal.Notify(c, os.Interrupt)
	go func() {
		select {
		case <-c:
			log.Println("Stop profiling")
			pprof.StopCPUProfile()
			syscall.Exit(0)
		}
	}()

	props := property.Init()
	evStore, err := evstore.Dial(props["mongodb.url"], props["mongodb.db"], props["mongodb.stream"])
	if err != nil {
		log.Fatalln("Error connecting to event store. ", err)
	}
	wsServer := wsock.NewServer(props["events.uri"])
	if wsServer == nil {
		log.Fatalln("Error creating new websocket server")
	}
	go processClientConnection(wsServer, evStore)
	go wsServer.Listen()

	//http.Handle(props["static.url"], http.FileServer(http.Dir("webroot")))
	err = http.ListenAndServe(props["events.url"], nil)
	evStore.Close()
}
Exemple #8
0
func main() {
	var id string
	flag.StringVar(&id, "id", "", "ID to subscribe from")
	flag.Parse()
	props := property.Init()

	evStore, err := evstore.Dial(props["mongodb.url"], props["mongodb.db"], props["mongodb.stream"])
	if err != nil {
		log.Fatalln("Error connecting to event store. ", err)
	}
	wsServer := wsock.NewServer(props["configsrv.uri"])
	if wsServer == nil {
		log.Fatalln("Error creating new websocket server")
	}
	currentConfig = Config{}
	currentConfig.mx = &sync.Mutex{}
	isCurrent = false
	stateUpdateChannel := make(chan *bson.M, 256)
	err = evStore.Listenner2().Subscribe2("config", configHandler)
	if err != nil {
		log.Fatalln("Error subscribing for config changes", err)
	}
	ctx1, cancel := context.WithCancel(context.Background())
	ctx := context.WithValue(ctx1, "stateUpdateChannel", stateUpdateChannel)
	defer cancel()
	log.Println("Before Listen call")
	go evStore.Listenner2().Listen(ctx, id)

	go processClientConnection(ctx, wsServer)
	go wsServer.Listen()

	//http.Handle(props["static.url"], http.FileServer(http.Dir("webroot")))
	err = http.ListenAndServe(props["configsrv.url"], nil)
	evStore.Close()
}
func TestGetHistory(t *testing.T) {
	var (
		m map[string]interface{}
	)
	evStore, err := evstore.Dial("localhost", dbName, "test")
	if err != nil {
		t.Fatal(err)
	}
	rpc := NewRPCFunctionInterface(evStore)
	if err != nil {
		t.Fatal(err)
	}
	if rpc == nil {
		t.Fatal("RPCFunctionInterface is nil")
	}
	f, err := rpc.GetFunction("GetHistory")
	if err != nil {
		t.Fatal(err)
	}
	if f == nil {
		t.Fatal("Function is nil")
	}
	evStore.Manager().DropDatabase(dbName)
	msg1 := "{\"message\":\"NOT expected\"}"
	evStore.Committer().SubmitEvent("", "test", msg1)
	<-time.After(2 * time.Second)
	tStart := time.Now()
	for n := 0; n < 10; n++ {
		fmt.Printf(".")
		msg2 := "{\"message\":\"" + strconv.Itoa(n) + "\"}"
		evStore.Committer().SubmitEvent("", "test", msg2)
		<-time.After(500 * time.Millisecond)
	}
	tStop := time.Now()
	<-time.After(2 * time.Second)
	evStore.Committer().SubmitEvent("", "test", msg1)
	log.Println(tStart, " < ", tStop)
	c, err := f.(func(time.Time, time.Time) (chan string, error))(tStart, tStop)
	if err != nil {
		t.Fatal(err)
	}
	if c == nil {
		t.Fatal("Channel shouldn't be nil")
	}
	for {
		msg, ok := <-c
		if !ok {
			break
		}
		log.Println(msg)
		err = json.Unmarshal([]byte(msg), &m)
		if err != nil {
			t.Fatal(err)
		}
		//		if m["event"].(map[string]interface{})["message"] != "expected" {
		//			t.Fatal(m["event"].(map[string]interface{})["message"])
		//		}
	}
}
func TestGetFirstEventByType(t *testing.T) {
	var (
		m map[string]interface{}
	)
	evStore, err := evstore.Dial("localhost", dbName, "test")
	if err != nil {
		t.Fatal(err)
	}
	rpc := NewRPCFunctionInterface(evStore)
	if err != nil {
		t.Fatal(err)
	}
	if rpc == nil {
		t.Fatal("RPCFunctionInterface is nil")
	}
	f, err := rpc.GetFunction("GetFirstEvent")
	if err != nil {
		t.Fatal(err)
	}
	if f == nil {
		t.Fatal("Function is nil")
	}
	evStore.Manager().DropDatabase(dbName)
	for n := 0; n < 100; n++ {
		msg2 := "{\"Fake event before\":" + strconv.Itoa(n) + "}"
		evStore.Committer().SubmitEvent("", "scalar", msg2)
	}
	msg1 := "{\"message\":\"First event of type test\"}"
	evStore.Committer().SubmitEvent("", "test", msg1)
	for n := 0; n < 100; n++ {
		msg2 := "{\"Fake event\":" + strconv.Itoa(n) + "}"
		evStore.Committer().SubmitEvent("", "scalar", msg2)
	}
	c, err := f.(func(tag string) (chan string, error))("test")
	if err != nil {
		t.Fatal(err)
	}
	if c == nil {
		t.Fatal("Channel shouldn't be nil")
	}
	msgCounter := 0
	for msg := range c {
		msgCounter = msgCounter + 1
		err = json.Unmarshal([]byte(msg), &m)
		if err != nil {
			t.Fatal(err)
		}
		if m["event"].(map[string]interface{})["message"] != "First event of type test" {
			t.Fatal("Incorrect message retuned: ", m["message"])
		}
	}
	if msgCounter == 0 {
		t.Fatal("No message recieved from database")
	}
	if msgCounter > 1 {
		t.Fatal("Too many messages returned", msgCounter)
	}

}
func TestNewRPCFunctionInterface(t *testing.T) {
	c, err := evstore.Dial("localhost", dbName, "test")
	if err != nil {
		t.Fatal("Error connecting to evstore")
	}
	rpc := NewRPCFunctionInterface(c)
	if err != nil {
		t.Fatal(err)
	}
	if rpc == nil {
		t.Fatal("RPCFunctionInterface is nil")
	}
}
Exemple #12
0
func main() {
	var (
		fileName       string
		uri            string
		dbName         string
		collectionName string
		msg            string
		genFile        string
	)
	flag.StringVar(&fileName, "f", "", "JSON file name with events")
	flag.StringVar(&uri, "s", "", "Event store URI")
	flag.StringVar(&dbName, "db", "", "Database name")
	flag.StringVar(&collectionName, "c", "", "Collection name")
	flag.StringVar(&msg, "msg", "", "Message to send to database")
	flag.StringVar(&genFile, "gen", "", "Genfile with information")
	flag.Parse()
	evStore, err := evstore.Dial(uri, dbName, collectionName)
	if err != nil {
		log.Panicln(err)
	}
	if fileName != "" {
		if _, err = os.Stat(fileName); err != nil {
			log.Panicln(err)
		}
		f, err := os.Open(fileName)
		if err != nil {
			log.Panicln(err)
		}
		r := bufio.NewReader(f)
		send2EventStore(r, evStore)
	}
	if msg != "" {
		err = evStore.Committer().SubmitEvent("", "scalar", msg)
		if err != nil {
			log.Panicln(err)
		}
	}
	if genFile != "" {
		if _, err := os.Stat(genFile); err != nil {
			log.Panicln(err)
		}
		f, err := os.Open(genFile)
		if err != nil {
			log.Panicln(err)
		}
		r := bufio.NewReader(f)
		log.Println("Start GenDataFromGenFile")
		genDataFromGenFile(context.Background(), r, evStore)
	}
	evStore.Close()
}
func submitEvent2Datastore(url string,
	database string,
	streamName string,
	seqid string,
	tag string,
	event map[string]interface{}) error {
	ev, err := evstore.Dial(url, database, streamName)
	if err != nil {
		return err
	}
	defer ev.Close()
	err = ev.Committer().SubmitMapStringEvent(seqid, tag, event)
	if err != nil {
		return err
	}
	return nil
}
Exemple #14
0
func main() {

	props := property.Init()
	evStore, err := evstore.Dial(props["mongodb.url"], props["mongodb.db"], props["mongodb.stream"])
	if err != nil {
		log.Fatalln("Error connecting to event store. ", err)
	}
	f := RPCFunction{evStore}
	wsServer := wsock.NewServer(props["rpceventsrv.uri"])
	if wsServer == nil {
		log.Fatalln("Error creating new websocket server")
	}
	go processClientConnection(wsServer, &f)
	go wsServer.Listen()

	//http.Handle(props["static.url"], http.FileServer(http.Dir("webroot")))
	err = http.ListenAndServe(props["rpceventsrv.url"], nil)
	evStore.Close()
}
func TestNegativeGetFunction(t *testing.T) {
	evStore, err := evstore.Dial("localhost", dbName, "test")
	if err != nil {
		t.Fatal(err)
	}
	rpc := NewRPCFunctionInterface(evStore)
	if err != nil {
		t.Fatal(err)
	}
	if rpc == nil {
		t.Fatal("RPCFunctionInterface is nil")
	}
	f, err := rpc.GetFunction("EchoFake")
	if err == nil {
		t.Fatal(err)
	}
	if f != nil {
		t.Fatal("Function isn't nil")
	}
}
func processClientConnection(s *wsock.Server, props property.PropSet) {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()
	log.Println("Enter processClientConnection")
	addCh, delCh, doneCh, _ := s.GetChannels()
	log.Println("Get server channels", addCh, delCh, doneCh)
Loop:
	for {
		select {
		case <-doneCh:
			log.Println("doneCh got message")
			break Loop
		case <-ctx.Done():
			log.Println("Context destroyed")
			break Loop
		case cli := <-addCh:
			log.Println("processClientConnection got add client notification", cli.Request().FormValue("id"))
			streamName := cli.Conn().Request().FormValue("stream")
			if streamName == "" {
				streamName = props["mongodb.stream"]
			}
			ctx, cancel := context.WithCancel(context.Background())
			defer cancel()
			log.Println("Stream name", streamName)
			evStore, err := evstore.Dial(props["mongodb.url"], props["mongodb.db"], streamName)
			defer evStore.Close()
			if err != nil {
				log.Fatalln("Error connecting to event store. ", err)
				return
			}
			go handleClientRequest(ctx, cli, evStore)
			break
		case cli := <-delCh:
			log.Println("delCh go client", cli)
			break
		}
	}
	log.Println("processClientConnection exited")
}
Exemple #17
0
func main() {
	var id string
	flag.StringVar(&id, "id", "", "ID to subscribe from")
	flag.Parse()
	props := property.Init()

	evStore, err := evstore.Dial(props["mongodb.url"], props["mongodb.db"], props["mongodb.stream"])
	if err != nil {
		log.Fatalln("Error connecting to event store. ", err)
	}
	wsServer := wsock.NewServer(props["current.uri"])
	if wsServer == nil {
		log.Fatalln("Error creating new websocket server")
	}
	sState = ScalarState{}
	sState.state = make(map[int]map[int]*bson.M)
	sState.mx = &sync.Mutex{}
	isCurrent = false
	stateUpdate := pubsub.NewPublisher(time.Millisecond*100, 1024)
	err = evStore.Listenner2().Subscribe2("scalar", scalarHandler)
	if err != nil {
		log.Fatalln("Error subscribing for changes", err)
	}
	ctx1, cancel := context.WithCancel(context.Background())
	ctx := context.WithValue(ctx1, "stateUpdate", stateUpdate)
	defer cancel()
	sState.lastID = evStore.Listenner2().GetLastID()
	log.Println("Before Listen call")
	go evStore.Listenner2().Listen(ctx, id)

	go processClientConnection(ctx, wsServer)
	go wsServer.Listen()

	//http.Handle(props["static.url"], http.FileServer(http.Dir("webroot")))
	err = http.ListenAndServe(props["current.url"], nil)
	evStore.Close()
}
func TestGetEventAt(t *testing.T) {
	var (
		m map[string]interface{}
	)
	evStore, err := evstore.Dial("localhost", dbName, "test")
	if err != nil {
		t.Fatal(err)
	}
	rpc := NewRPCFunctionInterface(evStore)
	if err != nil {
		t.Fatal(err)
	}
	if rpc == nil {
		t.Fatal("RPCFunctionInterface is nil")
	}
	f, err := rpc.GetFunction("GetEventAt")
	if err != nil {
		t.Fatal(err)
	}
	if f == nil {
		t.Fatal("Function is nil")
	}
	evStore.Manager().DropDatabase(dbName)
	msg1 := "{\"message\":\"First event\"}"
	evStore.Committer().SubmitEvent("", "test", msg1)
	for n := 0; n < 50; n++ {
		msg2 := "{\"Counter\":" + strconv.Itoa(n) + "}"
		evStore.Committer().SubmitEvent("", "test", msg2)
	}
	tPoint := time.Now()
	<-time.After(100 * time.Millisecond)
	for n := 50; n < 100; n++ {
		msg2 := "{\"Counter\":" + strconv.Itoa(n) + "}"
		evStore.Committer().SubmitEvent("", "test", msg2)
	}
	msgLast := "{\"message\":\"Last event\"}"
	evStore.Committer().SubmitEvent("", "test", msgLast)
	c, err := f.(func(tag string, timePoint time.Time) (chan string, error))("", tPoint)
	if err != nil {
		t.Fatal(err)
	}
	if c == nil {
		t.Fatal("Channel shouldn't be nil")
	}
	msgCounter := 0
	for msg := range c {
		log.Println(msg)
		msgCounter = msgCounter + 1
		err = json.Unmarshal([]byte(msg), &m)
		if err != nil {
			t.Fatal(err)
		}
		if int(m["event"].(map[string]interface{})["Counter"].(float64)) != 49 {
			t.Fatal("Incorrect message retuned: ", m["event"])
		}
	}
	if msgCounter == 0 {
		t.Fatal("No message recieved from database")
	}
	if msgCounter > 1 {
		t.Fatal("Too many messages returned", msgCounter)
	}

}
func TestGetDistanceValue(t *testing.T) {
	var (
		m map[string]interface{}
	)
	evStore, err := evstore.Dial("localhost", dbName, "test")
	if err != nil {
		t.Fatal(err)
	}
	rpc := NewRPCFunctionInterface(evStore)
	if err != nil {
		t.Fatal(err)
	}
	if rpc == nil {
		t.Fatal("RPCFunctionInterface is nil")
	}
	f, err := rpc.GetFunction("GetDistanceValue")
	if err != nil {
		t.Fatal(err)
	}
	if f == nil {
		t.Fatal("Function is nil")
	}
	evStore.Manager().DropDatabase(dbName)
	msg1 := "{\"message\":\"NOT expected\"}"
	evStore.Committer().SubmitEvent("", "test", msg1)
	<-time.After(1 * time.Second)
	tStart := time.Now()
	<-time.After(10 * time.Millisecond)
	for n := 0; n < 100; n++ {
		fmt.Printf(".")
		msg2 := "{\"value\":" + strconv.Itoa(n) + "}"
		evStore.Committer().SubmitEvent("", "scalar", msg2)
		<-time.After(100 * time.Millisecond)
	}
	tStop := time.Now()
	<-time.After(2 * time.Second)
	evStore.Committer().SubmitEvent("", "test", msg1)
	log.Println(tStart, " < ", tStop)
	c, err := f.(func(time.Time, time.Time, int) (chan string, error))(tStart, tStop, 10)
	if err != nil {
		t.Fatal(err)
	}
	if c == nil {
		t.Fatal("Channel shouldn't be nil")
	}
	msgCounter := 0
	for {
		msg, ok := <-c
		if !ok {
			break
		}
		msgCounter = msgCounter + 1
		//		log.Println(msg)
		err = json.Unmarshal([]byte(msg), &m)
		if err != nil {
			t.Fatal(err)
		}
	}
	if msgCounter == 0 {
		t.Fatal("No message recieved from database")
	}
}
func TestSubmitErrorEvent(t *testing.T) {
	Convey("Submit event with no tag", t, func() {
		var (
			results []interface{}
		)
		props := property.Init()
		CleanupCollections()
		ev, err := evstore.Dial(props["mongodb.url"], dbName, "submitevents")
		So(err, ShouldBeNil)
		So(ev, ShouldNotBeNil)
		c := makeStubClient()
		ctx, cancel := context.WithCancel(context.Background())
		defer cancel()
		fromWS, toWS, _ := c.GetChannels()
		go handleClientRequest(ctx, c, ev)
		m := wsock.MessageT{}
		m["sequenceid"] = ""
		m["event"] = map[string]interface{}{"event": "no tag"}
		fromWS <- &m
		<-time.After(time.Millisecond * 100)
		msg := <-toWS
		So((*msg)["reply"].(string), ShouldEqual, "ERROR")
		So((*msg)["msg"].(string), ShouldEqual, "No tag")
		session, err := mgo.Dial(props["mongodb.url"])
		So(err, ShouldBeNil)
		So(session, ShouldNotBeNil)
		defer session.Close()
		iter := session.DB(dbName).C("submitevents").Find(nil).Iter()
		So(iter, ShouldNotBeNil)
		iter.All(&results)
		So(results, ShouldBeNil)

	})
	Convey("Submit event with no event", t, func() {
		var (
			results []interface{}
		)
		props := property.Init()
		CleanupCollections()
		ev, err := evstore.Dial(props["mongodb.url"], dbName, "submitevents")
		So(err, ShouldBeNil)
		So(ev, ShouldNotBeNil)
		c := makeStubClient()
		ctx, cancel := context.WithCancel(context.Background())
		defer cancel()
		fromWS, toWS, _ := c.GetChannels()
		go handleClientRequest(ctx, c, ev)
		m := wsock.MessageT{}
		m["sequenceid"] = ""
		m["tag"] = "test"
		fromWS <- &m
		<-time.After(time.Millisecond * 100)
		msg := <-toWS
		So((*msg)["reply"].(string), ShouldEqual, "ERROR")
		So((*msg)["msg"].(string), ShouldEqual, "No event")
		session, err := mgo.Dial(props["mongodb.url"])
		So(err, ShouldBeNil)
		So(session, ShouldNotBeNil)
		defer session.Close()
		iter := session.DB(dbName).C("submitevents").Find(nil).Iter()
		So(iter, ShouldNotBeNil)
		iter.All(&results)
		So(results, ShouldBeNil)

	})
}