Add tests

Author: thani-sh

server/handler_connect_test.go

@@ -0,0 +1,23 @@
+package server
+
+import (
+	"testing"
+)
+
+func TestHandleConnect(t *testing.T) {
+	s := Server{}
+	h := NewConnectHandler(s)
+	m := Message{}
+	r := &TestResponse{}
+
+	h.handle(r, m)
+	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")
+	}
+}

server/handler_method_test.go

@@ -0,0 +1,36 @@
+package server
+
+import (
+	"testing"
+)
+
+func TestUnavailableMethod(t *testing.T) {
+	s := Server{}
+	h := NewMethodHandler(s)
+	m := Message{Method: "test"}
+	r := &TestResponse{}
+
+	if err := h.handle(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)}
+	h := NewMethodHandler(s)
+	m := Message{Method: "test"}
+	r := &TestResponse{}
+	b := false
+
+	s.methods["test"] = func(ctx MethodContext) {
+		b = true
+	}
+
+	if err := h.handle(r, m); err != nil {
+		t.Error("an error must not be returned if method is available")
+	}
+
+	if !b {
+		t.Error("method handler must be called")
+	}
+}

server/handler_ping_test.go

@@ -0,0 +1,39 @@
+package server
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestHandlePingWithoutID(t *testing.T) {
+	s := Server{}
+	h := NewPingHandler(s)
+	m := Message{}
+	r := &TestResponse{}
+	h.handle(r, m)
+
+	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{}
+	h := NewPingHandler(s)
+	m := Message{ID: "test-id"}
+	r := &TestResponse{}
+	h.handle(r, m)
+
+	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/method_context_test.go

@@ -0,0 +1,121 @@
+package server
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestSendResult(t *testing.T) {
+	r := &TestResponse{}
+	ctx := MethodContext{ID: "test-id", Res: r}
+	err := ctx.SendResult(100)
+
+	expected := map[string]interface{}{
+		"msg":    "result",
+		"id":     "test-id",
+		"result": 100,
+	}
+
+	if err != nil {
+		t.Error("result should be sent successfully")
+	}
+
+	if !ctx.Done {
+		t.Error("context must set that a result is sent")
+	}
+
+	if !reflect.DeepEqual(r._data, expected) {
+		t.Error("invalid response for method result")
+	}
+}
+
+func TestSendResultWhenDone(t *testing.T) {
+	r := &TestResponse{}
+	ctx := MethodContext{ID: "test-id", Res: r, Done: true}
+	err := ctx.SendResult(100)
+
+	if err == nil {
+		t.Error("result should be sent only once")
+	}
+
+	if r._data != nil {
+		t.Error("result should be sent only once")
+	}
+}
+
+func TestSendError(t *testing.T) {
+	r := &TestResponse{}
+	ctx := MethodContext{ID: "test-id", Res: r}
+	err := ctx.SendError("test-error")
+
+	expected := map[string]interface{}{
+		"msg": "result",
+		"id":  "test-id",
+		"error": map[string]string{
+			"error": "test-error",
+		},
+	}
+
+	if err != nil {
+		t.Error("error should be sent successfully")
+	}
+
+	if !ctx.Done {
+		t.Error("context must set that a result is sent")
+	}
+
+	if !reflect.DeepEqual(r._data, expected) {
+		t.Error("invalid response for method error")
+	}
+}
+
+func TestSendErrorWhenDone(t *testing.T) {
+	r := &TestResponse{}
+	ctx := MethodContext{ID: "test-id", Res: r, Done: true}
+	err := ctx.SendError("test-error")
+
+	if err == nil {
+		t.Error("error should be sent only once")
+	}
+
+	if r._data != nil {
+		t.Error("error should be sent only once")
+	}
+}
+
+func TestSendUpdated(t *testing.T) {
+	r := &TestResponse{}
+	ctx := MethodContext{ID: "test-id", Res: r}
+	err := ctx.SendUpdated()
+
+	expected := map[string]interface{}{
+		"msg":     "updated",
+		"methods": []string{"test-id"},
+	}
+
+	if err != nil {
+		t.Error("updated should be sent successfully")
+	}
+
+	if !ctx.Updated {
+		t.Error("context must set that updated is sent")
+	}
+
+	if !reflect.DeepEqual(r._data, expected) {
+		t.Error("invalid response for method updated")
+	}
+}
+
+func TestSendUpdatedWhenDone(t *testing.T) {
+	r := &TestResponse{}
+	ctx := MethodContext{ID: "test-id", Res: r, Updated: true}
+	err := ctx.SendUpdated()
+
+	if err == nil {
+		t.Error("updated message should be sent only once")
+	}
+
+	if r._data != nil {
+		t.Error("updated message should be sent only once")
+	}
+}

server/server_test.go

@@ -0,0 +1,50 @@
+package server
+
+import (
+	"errors"
+	"testing"
+)
+
+func TestAddMethod(t *testing.T) {
+	s := New()
+	s.Method("testfn", func(MethodContext) {})
+	if _, ok := s.methods["testfn"]; !ok {
+		t.Error("method functionm ust be stored under methods")
+	}
+}
+
+func TestReadMessageReadError(t *testing.T) {
+	req := TestRequest{Error: errors.New("test-error")}
+	if _, err := readMessage(&req); err == nil {
+		t.Error("an error must be returned if reading from Request fails")
+	}
+}
+
+func TestReadMessageBinaryMessage(t *testing.T) {
+	req := TestRequest{Type: 2}
+	if _, err := readMessage(&req); err == nil {
+		t.Error("an error must be returned if type is binary")
+	}
+}
+
+func TestReadMessageInvalidMessage(t *testing.T) {
+	str := []byte("invalid-json")
+	req := TestRequest{Type: 1, Message: str}
+	if _, err := readMessage(&req); err == nil {
+		t.Error("an error must be returned if message is not json")
+	}
+}
+
+func TestReadMessageValidMessage(t *testing.T) {
+	str := []byte(`{"msg": "ping"}`)
+	req := TestRequest{Type: 1, Message: str}
+	msg, err := readMessage(&req)
+
+	if err != nil {
+		t.Error("message must be read successfully")
+	}
+
+	if msg.Msg != "ping" {
+		t.Error("message must have correct message type")
+	}
+}

server/types_test.go

@@ -0,0 +1,20 @@
+package server
+
+type TestResponse struct {
+	_data interface{}
+}
+
+func (t *TestResponse) WriteJSON(d interface{}) error {
+	t._data = d
+	return nil
+}
+
+type TestRequest struct {
+	Type    int
+	Message []byte
+	Error   error
+}
+
+func (t *TestRequest) ReadMessage() (int, []byte, error) {
+	return t.Type, t.Message, t.Error
+}