Simplify code. Use functions for handlers

Author: thani-sh

server/handler_connect.go

@@ -3,17 +3,13 @@ package server
 import (
 	"encoding/json"
 	"errors"
+	"fmt"
 	"net/http"
 
 	"github.com/gorilla/websocket"
+	"github.com/meteorhacks/goddp/utils/random"
 )
 
-type Server struct {
-	handlers map[string]Handler
-	methods  map[string]MethodFn
-	upgrader websocket.Upgrader
-}
-
 func New() Server {
 	s := Server{}
 	s.methods = make(map[string]MethodFn)
@@ -22,15 +18,14 @@ func New() Server {
 		WriteBufferSize: 1024,
 	}
 
-	s.handlers = map[string]Handler{
-		"connect": NewConnectHandler(s),
-		"ping":    NewPingHandler(s),
-		"method":  NewMethodHandler(s),
-	}
-
 	return s
 }
 
+type Server struct {
+	methods  map[string]MethodFn
+	upgrader websocket.Upgrader
+}
+
 func (s *Server) Listen(addr string) {
 	http.HandleFunc("/websocket", s.Handler)
 	http.ListenAndServe(addr, nil)
@@ -48,15 +43,20 @@ func (s *Server) Handler(w http.ResponseWriter, r *http.Request) {
 	}
 
 	for {
-		msg, err := readMessage(req)
+		msg, err := readMessage(ws)
 
 		if err != nil {
 			break
 		}
 
-		if h, ok := s.handlers[msg.Msg]; ok {
-			go h.handle(res, msg)
-		} else {
+		switch msg.Msg {
+		case "connect":
+			handleConnect(s, ws, msg)
+		case "ping":
+			handlePing(s, ws, msg)
+		case "method":
+			handleMethod(s, ws, msg)
+		default:
 			// TODO => send "error" ddp message
 			break
 		}
@@ -84,3 +84,36 @@ func readMessage(req Request) (Message, error) {
 
 	return msg, nil
 }
+
+func handleConnect(s *Server, res Response, m Message) error {
+	return res.WriteJSON(map[string]string{
+		"msg":     "connected",
+		"session": random.Id(17),
+	})
+}
+
+func handleMethod(s *Server, res Response, m Message) error {
+	fn, ok := s.methods[m.Method]
+
+	if !ok {
+		err := errors.New(fmt.Sprintf("method %s not found", m.Method))
+		return err
+	}
+
+	ctx := NewMethodContext(m, res)
+	go fn(ctx)
+
+	return nil
+}
+
+func handlePing(s *Server, res Response, m Message) error {
+	msg := map[string]string{
+		"msg": "pong",
+	}
+
+	if m.ID != "" {
+		msg["id"] = m.ID
+	}
+
+	return res.WriteJSON(msg)
+}

server/handler_connect_test.go

@@ -2,6 +2,7 @@ package server
 
 import (
 	"errors"
+	"reflect"
 	"testing"
 )
 
@@ -48,3 +49,87 @@ func TestReadMessageValidMessage(t *testing.T) {
 		t.Error("message must have correct message type")
 	}
 }
+
+func TestHandleConnect(t *testing.T) {
+	s := &Server{}
+	m := Message{}
+	r := &TestResponse{}
+
+	if err := handleConnect(s, r, m); err != nil {
+		t.Error("connect should be handled successfully")
+	}
+
+	data := r._data.(map[string]string)
+	if data["msg"] != "connected" {
+		t.Error("msg field should be 'connected'")
+	}
+
+	if len(data["session"]) != 17 {
+		t.Error("session field should be have 17 characters")
+	}
+}
+
+func TestUnavailableMethod(t *testing.T) {
+	s := &Server{}
+	m := Message{Method: "test"}
+	r := &TestResponse{}
+
+	if err := handleMethod(s, r, m); err == nil {
+		t.Error("an error must be returned if method is not available")
+	}
+}
+
+func TestAvailableMethod(t *testing.T) {
+	s := &Server{methods: make(map[string]MethodFn)}
+	m := Message{Method: "test"}
+	r := &TestResponse{}
+	c := make(chan bool)
+
+	s.methods["test"] = func(ctx MethodContext) {
+		c <- true
+	}
+
+	if err := handleMethod(s, r, m); err != nil {
+		t.Error("an error must not be returned if method is available")
+	}
+
+	// block untill method is called
+	<-c
+}
+
+func TestHandlePingWithoutID(t *testing.T) {
+	s := &Server{}
+	m := Message{}
+	r := &TestResponse{}
+
+	if err := handlePing(s, r, m); err != nil {
+		t.Error("ping should be handled successfully")
+	}
+
+	expected := map[string]string{
+		"msg": "pong",
+	}
+
+	if !reflect.DeepEqual(r._data, expected) {
+		t.Error("message should only have msg field")
+	}
+}
+
+func TestHandlePingWithID(t *testing.T) {
+	s := &Server{}
+	m := Message{ID: "test-id"}
+	r := &TestResponse{}
+
+	if err := handlePing(s, r, m); err != nil {
+		t.Error("ping should be handled successfully")
+	}
+
+	expected := map[string]string{
+		"msg": "pong",
+		"id":  "test-id",
+	}
+
+	if !reflect.DeepEqual(r._data, expected) {
+		t.Error("message should have msg and ID fields")
+	}
+}

server/handler_method.go

@@ -8,11 +8,8 @@ type Response interface {
 	WriteJSON(interface{}) error
 }
 
-type Handler interface {
-	handle(Response, Message) error
-}
-
 type MethodFn func(MethodContext)
+type Handler func(*Server, Response, Message) error
 
 // This has the all the possible fields a DDP message can have
 type Message struct {