refactored the eventsource endpoint to make it testable. Added some basic smoke test.

Author: yml

main.go

@@ -110,7 +110,35 @@ func (h *Hub) run() {
 	}
 }
 
-// NewHub a pointer to an initialized Hub
+// EventSourceHandler implements the Handler interface
+func (h *Hub) EventSourceHandler(w http.ResponseWriter, req *http.Request) {
+	token := req.URL.Path[len(ssePath):]
+
+	if h.userExists(token) {
+		log.Println("[Info] Forbiden, user already connected")
+		http.Error(w, "Forbiden", http.StatusForbidden)
+	} else {
+		log.Println("[Info] Exchange token against the channel list", token)
+		val, err := h.client.Getset(token, []byte{})
+		if err != nil {
+			log.Println("[Error] occured while exchanging the your security token.", token, ":", err)
+			http.Error(w, "Error occured while exchanging the your security token", http.StatusUnauthorized)
+		} else if chanName := string(val); chanName != "" {
+			log.Println("[Info] Connecting", token, "to the channel", chanName)
+			h.register <- Connection{token, chanName}
+			defer func(u string) {
+				h.unregister <- u
+			}(token)
+			h.srv.Handler(token)(w, req)
+		}
+		_, err = h.client.Del(token)
+		if err != nil {
+			log.Println("[Error] An error occured while trying to delete the token from redis", err)
+		}
+	}
+}
+
+// NewHub returns a pointer to a initialized and running Hub
 func NewHub() *Hub {
 	redisURLString := os.Getenv("REDIS_SSEQUEUE_URL")
 	if redisURLString == "" {
@@ -140,6 +168,7 @@ func NewHub() *Hub {
 		srv:        server,
 		client:     goredis.Client{Addr: redisURL.Host, Db: redisDb},
 	}
+	go h.run()
 	return &h
 }
 
@@ -152,31 +181,9 @@ func main() {
 
 	log.Println("[Info] Starting the eventsource Hub")
 	h := NewHub()
-	go h.run()
 
 	// eventsource endpoints
-	http.HandleFunc(ssePath, func(w http.ResponseWriter, req *http.Request) {
-		token := req.URL.Path[len(ssePath):]
-
-		if h.userExists(token) {
-			log.Println("[Info] Forbiden, user already connected")
-			http.Error(w, "Forbiden", http.StatusForbidden)
-		} else {
-			log.Println("[Info] Exchange token against the channel list")
-			val, err := h.client.Getset(token, []byte{})
-			if err != nil {
-				log.Println("[Error] occured while exchanging the your security token.")
-				http.Error(w, "Error occured while exchanging the your security token", http.StatusUnauthorized)
-			} else if chanName := string(val); chanName != "" {
-				log.Println("[Info] Connecting", token, "to the channel", chanName)
-				h.register <- Connection{token, chanName}
-				defer func(u string) {
-					h.unregister <- u
-				}(token)
-				h.srv.Handler(token)(w, req)
-			}
-		}
-	})
+	http.HandleFunc(ssePath, h.EventSourceHandler)
 
 	log.Fatalln(http.ListenAndServe(sseString, nil))
 }

main_test.go

@@ -0,0 +1,91 @@
+package main
+
+import (
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"testing"
+	"time"
+)
+
+type closeNotifyingRecorder struct {
+	*httptest.ResponseRecorder
+	closed chan bool
+}
+
+func newCloseNotifyingRecorder() *closeNotifyingRecorder {
+	return &closeNotifyingRecorder{
+		httptest.NewRecorder(),
+		make(chan bool, 1),
+	}
+}
+
+func (c *closeNotifyingRecorder) close() {
+	c.closed <- true
+}
+
+func (c *closeNotifyingRecorder) CloseNotify() <-chan bool {
+	return c.closed
+}
+
+func TestEventSourceHandler(t *testing.T) {
+	h := NewHub()
+	setup := func() {
+		err := h.client.Set("existing-token", []byte("channelName"))
+		if err != nil {
+			t.Error("[Error] An error occured while setting up the test", err)
+		}
+	}
+	tearDown := func() {
+		_, err := h.client.Del("existing-token")
+		if err != nil {
+			t.Error("[Error] An error occured while tearing down the test", err)
+		}
+		_, err = h.client.Del("bad-token")
+		if err != nil {
+			t.Error("[Error] An error occured while tearing down the test", err)
+		}
+
+	}
+
+	tests := []struct {
+		Desc    string
+		Handler func(http.ResponseWriter, *http.Request)
+		Path    string
+		Status  int
+	}{
+		{
+			Desc:    "Access the EventSourceHandler with a bad-token",
+			Handler: h.EventSourceHandler,
+			Path:    ssePath + "bad-token",
+			Status:  http.StatusUnauthorized,
+		},
+		{
+			Desc:    "Access the EventSourceHandler with an existing-token",
+			Handler: h.EventSourceHandler,
+			Path:    ssePath + "existing-token",
+			Status:  http.StatusOK,
+		},
+	}
+	for _, test := range tests {
+		fmt.Println("[Testing]", test.Desc)
+		setup()
+		defer tearDown()
+		record := newCloseNotifyingRecorder()
+		req := &http.Request{
+			Method: "GET",
+			URL:    &url.URL{Path: test.Path},
+		}
+		go test.Handler(record, req)
+		// walk around a timing issue
+		// When we connect to the eventsrouce endpoint the connection is hold open
+		// so we need to start the handler in a goroutine else the test is blocking
+		time.Sleep(time.Second * 1)
+		record.CloseNotify()
+
+		if got, want := record.Code, test.Status; got != want {
+			t.Errorf("%s: response code = %d, want %d", test.Desc, got, want)
+		}
+	}
+}