Moved golang to version 1.23.0 and improved core features

Author: michaelchristopher-ui

.github/workflows/go.yml

@@ -0,0 +1,27 @@
+name: Upload Go test results
+
+on: [push]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        go-version: [ '1.23.0']
+
+    steps:
+      - uses: actions/checkout@v4
+      - name: Setup Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: ${{ matrix.go-version }}
+      - name: Install dependencies
+        run: go get .
+      - name: Test with Go
+        run: go test -json > TestResults-${{ matrix.go-version }}.json
+      - name: Upload Go test results
+        uses: actions/upload-artifact@v4
+        with:
+          name: Go-results-${{ matrix.go-version }}
+          path: TestResults-${{ matrix.go-version }}.json

README.md

@@ -11,6 +11,8 @@ A web application that serves as a load-balanced backend for a Chat Application,
 
 - One - to - One chat among friends that spans multiple chat server instances.
 
+- Simple Round-Robin Load Balancing with Nginx
+
 - Saving and paginated retrieval of messages within the database.
 
 - Logging through Filebeat as a Sidecar, Elasticsearch and Kibana.

api/http/apiintegrator.go

@@ -12,6 +12,7 @@ import (
 type APIIntegrator struct {
 	ChatService    chatadapter.Adapter
 	AccountService accountadapter.Adapter
+	Logger         loggeradapter.Adapter
 }
 
 /*
@@ -23,6 +24,7 @@ func NewAPIIntegrator(req NewAPIIntegratorReq) *APIIntegrator {
 	return &APIIntegrator{
 		ChatService:    req.ChatService,
 		AccountService: req.AccountService,
+		Logger:         req.Logger,
 	}
 }
 
@@ -37,6 +39,7 @@ func API(req APIReq) {
 	integrator := NewAPIIntegrator(NewAPIIntegratorReq{
 		ChatService:    req.ChatService,
 		AccountService: req.AccountService,
+		Logger:         req.Logger,
 	})
 
 	chat := req.E.Group("")

api/http/healthcheck.go

@@ -1,11 +1,15 @@
 package http
 
 import (
+	"fmt"
 	"net/http"
+	"time"
 
 	"github.com/labstack/echo"
 )
 
+// 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()))
 	return c.JSON(http.StatusOK, nil)
 }

api/http/healthcheck_test.go

@@ -0,0 +1,70 @@
+package http
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"websocket_client/internal/pkg/core/adapter/loggeradapter"
+
+	"github.com/golang/mock/gomock"
+	"github.com/labstack/echo"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestHealthCheck(t *testing.T) {
+	// Define mocks
+	mockCtrl := gomock.NewController(t)
+	mockLogger := loggeradapter.NewMockAdapter(mockCtrl)
+
+	// Define test data
+	type HealthCheckTestData struct {
+		name       string
+		mock       func()
+		assertions func(res error, rec *httptest.ResponseRecorder)
+	}
+
+	// Populate test data
+	tests := []HealthCheckTestData{
+		{
+			name: "Test if HealthCheck returns correct response",
+			mock: func() {
+				// No mocks needed for this simple function
+			},
+			assertions: func(res error, rec *httptest.ResponseRecorder) {
+				if assert.NoError(t, res) {
+					assert.Equal(t, http.StatusOK, rec.Code)
+					assert.Equal(t, "null\n", rec.Body.String())
+				}
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			// Create a new HTTP request
+			req := httptest.NewRequest(http.MethodGet, "/health", nil)
+
+			// Create a new HTTP response recorder
+			rec := httptest.NewRecorder()
+
+			// Create a new context
+			c := echo.New().NewContext(req, rec)
+
+			// Initialize tested struct
+			mockIntegrator := NewAPIIntegrator(
+				NewAPIIntegratorReq{
+					Logger: mockLogger,
+				},
+			)
+
+			// Execute mocks
+			test.mock()
+
+			// Run the tested function
+			res := mockIntegrator.HealthCheck(c)
+
+			// Check the assertions
+			test.assertions(res, rec)
+		})
+	}
+}

api/http/receivemessage.go

@@ -2,6 +2,7 @@ package http
 
 import (
 	"encoding/json"
+	"fmt"
 	"net/http"
 	"websocket_client/api/http/structs"
 	"websocket_client/internal/pkg/core/adapter/chatadapter"
@@ -14,23 +15,29 @@ func (integrator *APIIntegrator) ReceiveMessage(c echo.Context) error {
 	req := ReceiveMessageReq{}
 	err := json.NewDecoder(c.Request().Body).Decode(&req)
 	if err != nil {
+		integrator.Logger.NewError(fmt.Sprintf("[Integrator][ReceiveMesssage] Error when decoding request, err: %s", err.Error()))
 		return c.JSON(http.StatusInternalServerError, structs.ErrorRet{
 			Error: err.Error(),
 		})
 	}
-	err = integrator.ChatService.ReceiveMessage(chatadapter.ReceiveMessageReq{
+	isOnline, err := integrator.ChatService.ReceiveMessage(chatadapter.ReceiveMessageReq{
 		Message:    req.Message,
 		FromUserID: req.FromUserID,
 		Type:       req.Type,
 		ToUserID:   req.ToUserID,
 		Timestamp:  req.Timestamp,
 	})
-	if err != nil {
+	if isOnline && err != nil {
+		integrator.Logger.NewError(fmt.Sprintf("[Integrator][ReceiveMesssage] Error when sending message to online user, err: %s", err.Error()))
 		return c.JSON(http.StatusInternalServerError, structs.ErrorRet{
 			Error: err.Error(),
 		})
 	}
-	return c.JSON(http.StatusOK, nil)
+
+	integrator.Logger.NewInfo(fmt.Sprintf("[Integrator][ReceiveMesssage] Received message from user with ID %s to ID %s, user online = %v", req.FromUserID, req.ToUserID, isOnline))
+	return c.JSON(http.StatusOK, ReceiveMessageRes{
+		IsOnline: isOnline,
+	})
 }
 
 type ReceiveMessageReq struct {
@@ -40,3 +47,7 @@ type ReceiveMessageReq struct {
 	ToUserID   string `json:"to_user_id"`
 	Timestamp  string `json:"timestamp"`
 }
+
+type ReceiveMessageRes struct {
+	IsOnline bool `json:"is_online"`
+}

api/http/receivemessage_test.go

@@ -0,0 +1,169 @@
+package http
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"websocket_client/api/http/structs"
+	"websocket_client/internal/pkg/core/adapter/chatadapter"
+	"websocket_client/internal/pkg/core/adapter/loggeradapter"
+
+	"github.com/golang/mock/gomock"
+	"github.com/labstack/echo"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestReceiveMessage(t *testing.T) {
+	// Define mocks
+	mockCtrl := gomock.NewController(t)
+	mockChatService := chatadapter.NewMockAdapter(mockCtrl)
+	mockLogger := loggeradapter.NewMockAdapter(mockCtrl)
+
+	// Define test data
+	type ReceiveMessageTestData struct {
+		name       string
+		wrongBody  bool
+		reqBody    ReceiveMessageReq
+		mock       func()
+		assertions func(res error, rec *httptest.ResponseRecorder)
+	}
+
+	// Populate test data
+	tests := []ReceiveMessageTestData{
+		{
+			name: "Test if correct body returns correct response provided the user is online",
+			reqBody: ReceiveMessageReq{
+				Message:    "Hello",
+				FromUserID: "user1",
+				Type:       1,
+				ToUserID:   "user2",
+				Timestamp:  "2025-04-02T06:53:00Z",
+			},
+			mock: func() {
+				mockChatService.EXPECT().ReceiveMessage(chatadapter.ReceiveMessageReq{
+					Message:    "Hello",
+					FromUserID: "user1",
+					Type:       1,
+					ToUserID:   "user2",
+					Timestamp:  "2025-04-02T06:53:00Z",
+				}).Return(true, nil).Times(1)
+			},
+			assertions: func(res error, rec *httptest.ResponseRecorder) {
+				if assert.NoError(t, res) {
+					assert.Equal(t, http.StatusOK, rec.Code)
+					expected, _ := json.Marshal(ReceiveMessageRes{
+						IsOnline: true,
+					})
+					assert.Equal(t, expected, rec.Body.String())
+				}
+			},
+		},
+		{
+			name: "Test if correct body returns correct response provided the user is not online",
+			reqBody: ReceiveMessageReq{
+				Message:    "Hello",
+				FromUserID: "user1",
+				Type:       1,
+				ToUserID:   "user2",
+				Timestamp:  "2025-04-02T06:53:00Z",
+			},
+			mock: func() {
+				mockChatService.EXPECT().ReceiveMessage(chatadapter.ReceiveMessageReq{
+					Message:    "Hello",
+					FromUserID: "user1",
+					Type:       1,
+					ToUserID:   "user2",
+					Timestamp:  "2025-04-02T06:53:00Z",
+				}).Return(false, nil).Times(1)
+			},
+			assertions: func(res error, rec *httptest.ResponseRecorder) {
+				if assert.NoError(t, res) {
+					assert.Equal(t, http.StatusOK, rec.Code)
+					expected, _ := json.Marshal(ReceiveMessageRes{
+						IsOnline: false,
+					})
+					assert.Equal(t, expected, rec.Body.String())
+				}
+			},
+		},
+		{
+			name: "Test if correct body returns error response provided the chat service returns an error",
+			reqBody: ReceiveMessageReq{
+				Message:    "Hello",
+				FromUserID: "user1",
+				Type:       1,
+				ToUserID:   "user2",
+				Timestamp:  "2025-04-02T06:53:00Z",
+			},
+			mock: func() {
+				mockChatService.EXPECT().ReceiveMessage(chatadapter.ReceiveMessageReq{
+					Message:    "Hello",
+					FromUserID: "user1",
+					Type:       1,
+					ToUserID:   "user2",
+					Timestamp:  "2025-04-02T06:53:00Z",
+				}).Return(errors.New("foo")).Times(1)
+			},
+			assertions: func(res error, rec *httptest.ResponseRecorder) {
+				if assert.NoError(t, res) {
+					assert.Equal(t, http.StatusInternalServerError, rec.Code)
+					expected, _ := json.Marshal(structs.ErrorRet{
+						Error: "foo",
+					})
+					assert.Equal(t, string(expected)+"\n", rec.Body.String())
+				}
+			},
+		},
+		{
+			name:      "Test if wrong body returns error",
+			wrongBody: true,
+			mock:      func() {},
+			assertions: func(res error, rec *httptest.ResponseRecorder) {
+				if assert.NoError(t, res) {
+					assert.Equal(t, http.StatusInternalServerError, rec.Code)
+					// We don't handle the error string for this one, we just assume there will be an error.
+					assert.True(t, bytes.Contains(rec.Body.Bytes(), []byte("\"error\"")))
+				}
+			},
+		},
+	}
+
+	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}")))
+			if !test.wrongBody {
+				jsonData, err := json.Marshal(test.reqBody)
+				assert.NoError(t, err)
+				req = httptest.NewRequest(http.MethodPost, "/", bytes.NewReader(jsonData))
+			}
+
+			// Create a new HTTP request
+
+			rec := httptest.NewRecorder()
+
+			// Create a new context
+			c := echo.New().NewContext(req, rec)
+
+			// Initialize tested struct
+			mockIntegrator := NewAPIIntegrator(
+				NewAPIIntegratorReq{
+					ChatService: mockChatService,
+					Logger:      mockLogger,
+				},
+			)
+
+			// Execute mocks
+			test.mock()
+
+			// Run the tested function
+			res := mockIntegrator.ReceiveMessage(c)
+
+			// Check the assertions
+			test.assertions(res, rec)
+		})
+	}
+}