Refactored code, added get user and tests for 80% coverage minimum

Author: michaelchristopher-ui

api/http/apiintegrator.go

@@ -1,18 +1,25 @@
 package http
 
 import (
+	"websocket_client/internal/conf"
 	"websocket_client/internal/pkg/core/adapter/accountadapter"
 	"websocket_client/internal/pkg/core/adapter/chatadapter"
 	"websocket_client/internal/pkg/core/adapter/loggeradapter"
+	"websocket_client/internal/pkg/core/adapter/wsprocessoradapter"
+	"websocket_client/internal/pkg/core/adapter/wsupgraderadapter"
 
-	"github.com/labstack/echo"
+	"github.com/labstack/echo/v4"
+	"github.com/labstack/echo/v4/middleware"
+	"golang.org/x/time/rate"
 )
 
 // APIIntegrator is the struct for all API handler methods
 type APIIntegrator struct {
 	ChatService    chatadapter.Adapter
 	AccountService accountadapter.Adapter
 	Logger         loggeradapter.Adapter
+	Upgrader       wsupgraderadapter.Adapter
+	WsProcessor    wsprocessoradapter.Adapter
 }
 
 /*
@@ -25,13 +32,17 @@ func NewAPIIntegrator(req NewAPIIntegratorReq) *APIIntegrator {
 		ChatService:    req.ChatService,
 		AccountService: req.AccountService,
 		Logger:         req.Logger,
+		Upgrader:       req.Upgrader,
+		WsProcessor:    req.WsProcessor,
 	}
 }
 
 type NewAPIIntegratorReq struct {
 	ChatService    chatadapter.Adapter
 	AccountService accountadapter.Adapter
 	Logger         loggeradapter.Adapter
+	Upgrader       wsupgraderadapter.Adapter
+	WsProcessor    wsprocessoradapter.Adapter
 }
 
 // API is a method that initializes the integrator and sets up all the APIs for the application
@@ -40,19 +51,27 @@ func API(req APIReq) {
 		ChatService:    req.ChatService,
 		AccountService: req.AccountService,
 		Logger:         req.Logger,
+		Upgrader:       req.Upgrader,
+		WsProcessor:    req.WsProcessor,
 	})
 
 	chat := req.E.Group("")
+	chat.Use(middleware.RateLimiter(middleware.NewRateLimiterMemoryStore(rate.Limit(conf.GetConfig().Server.RateLimit))))
 
-	chat.GET("/ws", integrator.Websocket)
 	chat.POST("/receive", integrator.ReceiveMessage)
 	chat.POST("/register", integrator.RegisterAccount)
 	chat.GET("/health_check", integrator.HealthCheck)
+
+	chatWs := req.E.Group("")
+	chatWs.Use(integrator.Auth, integrator.AddContextID)
+	chatWs.GET("/ws", integrator.HandleWebsocket)
 }
 
 type APIReq struct {
 	E              *echo.Echo
 	ChatService    chatadapter.Adapter
 	AccountService accountadapter.Adapter
 	Logger         loggeradapter.Adapter
+	Upgrader       wsupgraderadapter.Adapter
+	WsProcessor    wsprocessoradapter.Adapter
 }

api/http/constants.go

@@ -0,0 +1,12 @@
+package http
+
+//This group of constants define the possible incoming message types
+const (
+	incomingMessageTypeMessage        = "MESSAGE"
+	incomingMessageTypeAddFriend      = "ADDFRIEND"
+	incomingMessageTypeGetChatHistory = "GETCHATHISTORY"
+	incomingMessageTypeRemoveFriend   = "REMOVEFRIEND"
+	incomingMessageTypeSearchUser     = "SEARCHFRIEND"
+
+	returnErrorPasswordLength = "Password should be shorter than 72 characters"
+)

api/http/healthcheck.go

@@ -1,15 +1,14 @@
 package http
 
 import (
-	"fmt"
 	"net/http"
 	"time"
 
-	"github.com/labstack/echo"
+	"github.com/labstack/echo/v4"
 )
 
 // HealthCheck is a special API that will be called periodically by docker for their health checking functionality.
 func (integrator APIIntegrator) HealthCheck(c echo.Context) error {
-	integrator.Logger.NewInfo(fmt.Sprintf("[Integrator][HealthCheck] Health Check called at time %s", time.Now().String()))
+	integrator.Logger.NewInfo("Health Check called at time %s", time.Now().String())
 	return c.JSON(http.StatusOK, nil)
 }

api/http/healthcheck_test.go

@@ -7,7 +7,7 @@ import (
 	"websocket_client/internal/pkg/core/adapter/loggeradapter"
 
 	"github.com/golang/mock/gomock"
-	"github.com/labstack/echo"
+	"github.com/labstack/echo/v4"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -28,7 +28,7 @@ func TestHealthCheck(t *testing.T) {
 		{
 			name: "Test if HealthCheck returns correct response",
 			mock: func() {
-				mockLogger.EXPECT().NewInfo(gomock.Any()).Times(1)
+				mockLogger.EXPECT().NewInfo(gomock.Any(), gomock.Any()).Times(1)
 			},
 			assertions: func(res error, rec *httptest.ResponseRecorder) {
 				if assert.NoError(t, res) {

api/http/middleware.go

@@ -0,0 +1,49 @@
+package http
+
+import (
+	"websocket_client/internal/common"
+	"websocket_client/internal/pkg/core/adapter/accountadapter"
+
+	"github.com/labstack/echo/v4"
+)
+
+// AddContextID returns a function which generates FlowID and puts it within Context
+func (integrator *APIIntegrator) AddContextID(next echo.HandlerFunc) echo.HandlerFunc {
+	return func(c echo.Context) error {
+		/*
+			Generate FlowID for easy tracing
+			The FlowID is a UUID. Do take note of the RPS to find out when we should reset or recycle the UUIDs.
+		*/
+		flowID := common.GenerateUUID()
+		c.Set("flow_id", flowID)
+		return next(c)
+	}
+}
+
+// Auth is a rudimentary authorization function that checks whether the user exists in the database and the password is correct
+func (integrator *APIIntegrator) Auth(next echo.HandlerFunc) echo.HandlerFunc {
+	return func(c echo.Context) error {
+		var err error
+		defer func() {
+			if err != nil {
+				integrator.Logger.NewError(err.Error())
+			}
+		}()
+		userId, password, err := common.SplitUserIDAndPasswordFromAuth(c.Request().Header.Get("Authorization"))
+		if err != nil {
+			c.Error(err)
+			return err
+		}
+
+		err = integrator.AccountService.VerifyAuth(accountadapter.VerifyAuthReq{
+			UserID:   userId,
+			Password: password,
+		})
+
+		if err != nil {
+			c.Error(err)
+			return err
+		}
+		return next(c)
+	}
+}

api/http/middleware_test.go

@@ -0,0 +1,129 @@
+package http
+
+import (
+	"errors"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"websocket_client/internal/pkg/core/adapter/accountadapter"
+	"websocket_client/internal/pkg/core/adapter/loggeradapter"
+
+	"github.com/golang/mock/gomock"
+	"github.com/google/uuid"
+	"github.com/labstack/echo/v4"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestSetFlowID(t *testing.T) {
+	e := echo.New()
+	req := httptest.NewRequest(http.MethodGet, "/", nil)
+	rec := httptest.NewRecorder()
+	c := e.NewContext(req, rec)
+
+	// Call the function under test
+	dummyNextFunc := func(c echo.Context) error {
+		return nil
+	}
+
+	integrator := NewAPIIntegrator(NewAPIIntegratorReq{})
+
+	handlerFunc := integrator.AddContextID(dummyNextFunc)
+
+	err := handlerFunc(c)
+	assert.NoError(t, err)
+
+	val := c.Get("flow_id")
+	assert.NotNil(t, val)
+
+	strVal, ok := val.(string)
+	assert.True(t, ok)
+
+	// Optionally validate if strVal is a valid UUID (using github.com/google/uuid or similar)
+	if _, err = uuid.Parse(strVal); err != nil {
+		t.Errorf("Expected valid UUID for flow_id but got: %v", strVal)
+	}
+}
+
+func TestAuthenticationHandler(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+	mockAccountService := accountadapter.NewMockAdapter(ctrl)
+	mockLogger := loggeradapter.NewMockAdapter(ctrl)
+
+	tests := []struct {
+		name               string
+		authHeader         string
+		mock               func()
+		expectError        bool
+		expectedStatusCode int
+		expectLogCall      bool
+	}{
+		{
+			name:       "Successful Authentication",
+			authHeader: "Basic dXNlcjE6cGFzc3dvcmQx", // base64 user1:password1,
+			mock: func() {
+				mockAccountService.EXPECT().VerifyAuth(gomock.Any()).Return(nil).Times(1)
+			},
+			expectError:        false,
+			expectedStatusCode: http.StatusOK,
+			expectLogCall:      false,
+		},
+		{
+			name:       "Invalid Authorization Header",
+			authHeader: "InvalidHeader",
+			mock: func() {
+				mockLogger.EXPECT().NewError(gomock.Any()).Times(1)
+			},
+			expectError:        true,
+			expectedStatusCode: http.StatusInternalServerError,
+		},
+		{
+			name:       "Failed Verification",
+			authHeader: "Basic dXNlcjE6cGFzc3dvcmQx",
+			mock: func() {
+				mockAccountService.EXPECT().VerifyAuth(gomock.Any()).Return(errors.New("foo")).Times(1)
+				mockLogger.EXPECT().NewError(gomock.Any()).Times(1)
+			},
+			expectError:        true,
+			expectedStatusCode: http.StatusInternalServerError,
+		}}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Setup mocks based on test case:
+			integrator := NewAPIIntegrator(
+				NewAPIIntegratorReq{
+					AccountService: mockAccountService,
+					Logger:         mockLogger,
+				},
+			)
+
+			e := echo.New()
+			req := httptest.NewRequest(http.MethodGet, "/", nil)
+			req.Header.Set("Authorization", tt.authHeader)
+
+			rec := httptest.NewRecorder()
+
+			tt.mock()
+
+			c := e.NewContext(req, rec)
+
+			dummyNextFunc := func(c echo.Context) error {
+				return nil
+			}
+
+			handlerFunc := integrator.Auth(dummyNextFunc)
+			err := handlerFunc(c)
+
+			if tt.expectError {
+				assert.Error(t, err)
+				assert.Equal(t, tt.expectedStatusCode, rec.Code)
+			} else {
+				assert.NoError(t, err)
+				assert.Equal(t, tt.expectedStatusCode, rec.Code)
+			}
+		})
+
+	}
+
+}

api/http/receivemessage.go

@@ -7,7 +7,7 @@ import (
 	"websocket_client/api/http/structs"
 	"websocket_client/internal/pkg/core/adapter/chatadapter"
 
-	"github.com/labstack/echo"
+	"github.com/labstack/echo/v4"
 )
 
 // ReceiveMessage is the handler method for the /receive api endpoint.
@@ -20,10 +20,9 @@ func (integrator *APIIntegrator) ReceiveMessage(c echo.Context) error {
 			Error: err.Error(),
 		})
 	}
-	isOnline, err := integrator.ChatService.ReceiveMessage(chatadapter.ReceiveMessageReq{
+	isOnline, err := integrator.ChatService.ReceiveMessage(req.ToUserID, chatadapter.Message{
 		Message:    req.Message,
 		FromUserID: req.FromUserID,
-		Type:       req.Type,
 		ToUserID:   req.ToUserID,
 		Timestamp:  req.Timestamp,
 	})

api/http/receivemessage_test.go

@@ -12,7 +12,7 @@ import (
 	"websocket_client/internal/pkg/core/adapter/loggeradapter"
 
 	"github.com/golang/mock/gomock"
-	"github.com/labstack/echo"
+	"github.com/labstack/echo/v4"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -43,10 +43,9 @@ func TestReceiveMessage(t *testing.T) {
 				Timestamp:  "2025-04-02T06:53:00Z",
 			},
 			mock: func() {
-				mockChatService.EXPECT().ReceiveMessage(chatadapter.ReceiveMessageReq{
+				mockChatService.EXPECT().ReceiveMessage("user2", chatadapter.Message{
 					Message:    "Hello",
 					FromUserID: "user1",
-					Type:       1,
 					ToUserID:   "user2",
 					Timestamp:  "2025-04-02T06:53:00Z",
 				}).Return(true, nil).Times(1)
@@ -72,10 +71,9 @@ func TestReceiveMessage(t *testing.T) {
 				Timestamp:  "2025-04-02T06:53:00Z",
 			},
 			mock: func() {
-				mockChatService.EXPECT().ReceiveMessage(chatadapter.ReceiveMessageReq{
+				mockChatService.EXPECT().ReceiveMessage("user2", chatadapter.Message{
 					Message:    "Hello",
 					FromUserID: "user1",
-					Type:       1,
 					ToUserID:   "user2",
 					Timestamp:  "2025-04-02T06:53:00Z",
 				}).Return(false, nil).Times(1)
@@ -101,10 +99,9 @@ func TestReceiveMessage(t *testing.T) {
 				Timestamp:  "2025-04-02T06:53:00Z",
 			},
 			mock: func() {
-				mockChatService.EXPECT().ReceiveMessage(chatadapter.ReceiveMessageReq{
+				mockChatService.EXPECT().ReceiveMessage("user2", chatadapter.Message{
 					Message:    "Hello",
 					FromUserID: "user1",
-					Type:       1,
 					ToUserID:   "user2",
 					Timestamp:  "2025-04-02T06:53:00Z",
 				}).Return(false, errors.New("foo")).Times(1)
@@ -139,7 +136,7 @@ func TestReceiveMessage(t *testing.T) {
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
 			// Set up the body. Below, we handle one unique case first which is the invalid json before going to different requests controlled by the wrongBody boolean.
-			var req *http.Request = httptest.NewRequest(http.MethodPost, "/receive_message", bytes.NewReader([]byte("{invalid_json}")))
+			req := httptest.NewRequest(http.MethodPost, "/receive_message", bytes.NewReader([]byte("{invalid_json}")))
 			if !test.wrongBody {
 				jsonData, err := json.Marshal(test.reqBody)
 				assert.NoError(t, err)

api/http/registeraccount.go

@@ -7,7 +7,7 @@ import (
 	"websocket_client/api/http/structs"
 	"websocket_client/internal/pkg/core/adapter/accountadapter"
 
-	"github.com/labstack/echo"
+	"github.com/labstack/echo/v4"
 )
 
 // GetMessages is the handler method for the /get_messages api endpoint
@@ -22,9 +22,9 @@ func (integrator APIIntegrator) RegisterAccount(c echo.Context) error {
 	}
 	//Validate password length. Since we're using BCrypt it must be 72 characters or less, starting from the 0 index.
 	if len(req.Password) > 72 {
-		integrator.Logger.NewInfo(fmt.Sprintf("[Integrator][RegisterAccount] Password is not shorter than 72 bytes, ID: %s", req.UserID))
+		integrator.Logger.NewInfo(fmt.Sprintf("[Integrator][RegisterAccount] Password is not shorter than 72 characters, ID: %s", req.UserID))
 		return c.JSON(http.StatusBadRequest, structs.ErrorRet{
-			Error: "",
+			Error: returnErrorPasswordLength,
 		})
 	}