Added out file in github actions and added tests for wsstore

Author: michaelchristopher-ui

.github/workflows/go.yml

@@ -19,9 +19,12 @@ jobs:
       - name: Install dependencies
         run: go mod vendor
       - name: Test with Go
-        run: go test ./... -json > TestResults-${{ matrix.go-version }}.json
+        run: go test -coverprofile cover.out ./... -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
+          path: TestResults-${{ matrix.go-version }}.jso
+        
+
+        

cmd/app/main.go

@@ -76,9 +76,9 @@ func startServer() {
 		Redis:  rds,
 		Logger: lgr,
 		Sender: senderService,
-		WsStore: wsstoreservice.NewChatBackendService(wsstoreservice.NewWsStoreServiceReq{
+		WsStore: wsstoreservice.NewWSStoreService(wsstoreservice.NewWsStoreServiceReq{
 			UserConnections: map[string]wsconnadapter.Adapter{},
-			Lock:            map[string]*sync.Mutex{},
+			ConnLock:        map[string]sync.Locker{},
 		}),
 	})
 
@@ -87,9 +87,9 @@ func startServer() {
 		Logger: lgr,
 	})
 
-	wsstoreService := wsstoreservice.NewChatBackendService(wsstoreservice.NewWsStoreServiceReq{
+	wsstoreService := wsstoreservice.NewWSStoreService(wsstoreservice.NewWsStoreServiceReq{
 		UserConnections: make(map[string]wsconnadapter.Adapter),
-		Lock:            make(map[string]*sync.Mutex),
+		ConnLock:        make(map[string]sync.Locker),
 	})
 
 	upgraderService := wsupgrader.NewWsUpgraderService(wsupgrader.NewWsUpgraderServiceReq{

cover.out

@@ -0,0 +1,6 @@
+package lockeradapter
+
+import _ "github.com/golang/mock/mockgen/model" //When generating mocks in reflect mode, this workaround should be used.
+
+//go:generate mockgen -package=lockeradapter -destination=adapter_mock.go sync Locker
+//Instead of using our own adapter, we'll be using the built in sync.Locker interface

internal/pkg/core/adapter/lockeradapter/adapter.go

@@ -0,0 +1,5 @@
+package wsstoreservice
+
+const (
+	ErrConnExistString = "connection with user id %s exists"
+)

internal/pkg/core/adapter/lockeradapter/adapter_mock.go

@@ -9,71 +9,73 @@ import (
 
 type NewWsStoreServiceReq struct {
 	UserConnections map[string]wsconnadapter.Adapter
-	Lock            map[string]*sync.Mutex
+	ConnLock        map[string]sync.Locker
+	LockMutex       sync.Locker
 }
 
 type WsStore struct {
-	UserConnections map[string]wsconnadapter.Adapter
-	Lock            map[string]*sync.Mutex
-	LockMutex       sync.Mutex
+	userConnections map[string]wsconnadapter.Adapter //In memory store for the connections
+	connLock        map[string]sync.Locker           //Mutex for the connections
+	lockMutex       sync.Locker                      //Mutex for the maps
 }
 
-func NewChatBackendService(req NewWsStoreServiceReq) wsstoreadapter.Adapter {
+func NewWSStoreService(req NewWsStoreServiceReq) wsstoreadapter.Adapter {
 	return &WsStore{
-		UserConnections: req.UserConnections,
-		Lock:            req.Lock,
+		userConnections: req.UserConnections,
+		connLock:        req.ConnLock,
+		lockMutex:       req.LockMutex,
 	}
 }
 
 // AddConn adds a user connection key value entry in the online users map provided that it is able to obtain all required locks
 func (c *WsStore) AddConn(conn wsconnadapter.Adapter, userID string) error {
-	c.LockMutex.Lock()
-	defer c.LockMutex.Unlock()
-	if _, ok := c.Lock[userID]; !ok {
-		c.Lock[userID] = &sync.Mutex{}
+	c.lockMutex.Lock()
+	defer c.lockMutex.Unlock()
+	if _, ok := c.connLock[userID]; !ok {
+		c.connLock[userID] = &sync.Mutex{}
 	}
-	c.Lock[userID].Lock()
-	defer c.Lock[userID].Unlock()
-	if _, ok := c.UserConnections[userID]; !ok {
-		c.UserConnections[userID] = conn
+	c.connLock[userID].Lock()
+	defer c.connLock[userID].Unlock()
+	if _, ok := c.userConnections[userID]; !ok {
+		c.userConnections[userID] = conn
 		return nil
 	}
-	return fmt.Errorf("connection with user id %s exists", userID)
+	return fmt.Errorf(ErrConnExistString, userID)
 }
 
 /*
 GetConn locks the mutex associated with a specific connection, before returning the connection itself.
 After use, call the Release function to unlock the mutex.
 */
 func (c *WsStore) GetConn(userID string) wsconnadapter.Adapter {
-	c.LockMutex.Lock()
-	defer c.LockMutex.Unlock()
-	if _, ok := c.Lock[userID]; !ok {
+	c.lockMutex.Lock()
+	defer c.lockMutex.Unlock()
+	if _, ok := c.connLock[userID]; !ok {
 		return nil
 	}
-	c.Lock[userID].Lock()
-	if val, ok := c.UserConnections[userID]; ok {
+	c.connLock[userID].Lock()
+	if val, ok := c.userConnections[userID]; ok {
 		return val
 	}
 	return nil
 }
 
 // Release releases the lock for the specific connection
 func (c *WsStore) Release(userID string) {
-	c.LockMutex.Lock()
-	defer c.LockMutex.Unlock()
-	c.Lock[userID].Unlock() // There will always be a lock with userID for unlocking since deletion only occurs if we obtain the lock.
+	c.lockMutex.Lock()
+	defer c.lockMutex.Unlock()
+	c.connLock[userID].Unlock() // There will always be a lock with userID for unlocking since deletion only occurs if we obtain the lock.
 }
 
 // DeleteConn deletes a user entry in the online users map
 func (c *WsStore) DeleteConn(userID string) {
-	c.LockMutex.Lock()
-	defer c.LockMutex.Unlock()
+	c.lockMutex.Lock()
+	defer c.lockMutex.Unlock()
 	//We lock this for the final time before removing it, hence the absence of the unlock.
-	if _, ok := c.Lock[userID]; ok {
-		c.Lock[userID].Lock()
+	if _, ok := c.connLock[userID]; ok {
+		c.connLock[userID].Lock()
 	}
 	// Deletes are safe if key value pairs with supplied key do not exist
-	go delete(c.UserConnections, userID)
-	go delete(c.Lock, userID)
+	go delete(c.userConnections, userID)
+	go delete(c.connLock, userID)
 }

internal/pkg/core/service/wsstoreservice/constants.go

@@ -0,0 +1,180 @@
+package wsstoreservice_test
+
+import (
+	"sync"
+	"testing"
+
+	"websocket_client/internal/pkg/core/adapter/lockeradapter"
+	"websocket_client/internal/pkg/core/adapter/wsconnadapter"
+	"websocket_client/internal/pkg/core/service/wsstoreservice"
+
+	"github.com/golang/mock/gomock"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestAddConn(t *testing.T) {
+	ctrl := gomock.NewController(t)
+
+	mockLockMutex := lockeradapter.NewMockLocker(ctrl)
+	mockFooMutex := lockeradapter.NewMockLocker(ctrl)
+	mockConnLock := map[string]sync.Locker{
+		"foo": mockFooMutex,
+	}
+
+	mockConn := wsconnadapter.NewMockAdapter(ctrl)
+
+	tests := []struct {
+		name            string
+		mock            func()
+		userConnections map[string]wsconnadapter.Adapter
+		expectError     bool
+	}{
+		{
+			name: "Test AddConn creates and uses the mutexes properly before and after adding the new connection",
+			mock: func() {
+				mockLockMutex.EXPECT().Lock().Times(1)
+				mockFooMutex.EXPECT().Lock().Times(1)
+				mockFooMutex.EXPECT().Unlock().Times(1)
+				mockLockMutex.EXPECT().Unlock().Times(1)
+			},
+			userConnections: map[string]wsconnadapter.Adapter{},
+		},
+		{
+			name: "Test AddConn creates and uses the mutexes properly before and after adding the new connection, but connection exist",
+			mock: func() {
+				mockLockMutex.EXPECT().Lock().Times(1)
+				mockFooMutex.EXPECT().Lock().Times(1)
+				mockFooMutex.EXPECT().Unlock().Times(1)
+				mockLockMutex.EXPECT().Unlock().Times(1)
+			},
+			userConnections: map[string]wsconnadapter.Adapter{
+				"foo": mockConn,
+			},
+			expectError: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			mockWsStore := wsstoreservice.NewWSStoreService(wsstoreservice.NewWsStoreServiceReq{
+				ConnLock:        mockConnLock,
+				LockMutex:       mockLockMutex,
+				UserConnections: tt.userConnections,
+			})
+
+			tt.mock()
+			err := mockWsStore.AddConn(mockConn, "foo")
+			if tt.expectError {
+				assert.Error(t, err)
+			} else {
+				assert.NoError(t, err)
+			}
+		})
+	}
+}
+
+func TestGetConn(t *testing.T) {
+	ctrl := gomock.NewController(t)
+
+	mockLockMutex := lockeradapter.NewMockLocker(ctrl)
+	mockFooMutex := lockeradapter.NewMockLocker(ctrl)
+
+	mockConn := wsconnadapter.NewMockAdapter(ctrl)
+
+	tests := []struct {
+		name            string
+		mock            func()
+		userConnections map[string]wsconnadapter.Adapter
+		connLock        map[string]sync.Locker
+		expectedConn    wsconnadapter.Adapter
+	}{
+		{
+			name: "Test GetConn locks mutex and returns existing connection",
+			mock: func() {
+				mockLockMutex.EXPECT().Lock().Times(1)
+				mockFooMutex.EXPECT().Lock().Times(1)
+				mockLockMutex.EXPECT().Unlock().Times(1)
+			},
+			userConnections: map[string]wsconnadapter.Adapter{
+				"foo": mockConn,
+			},
+			connLock: map[string]sync.Locker{
+				"foo": mockFooMutex,
+			},
+			expectedConn: mockConn,
+		},
+		{
+			name: "Test GetConn returns nil if no mutex for userID",
+			mock: func() {
+				mockLockMutex.EXPECT().Lock().Times(1)
+				mockLockMutex.EXPECT().Unlock().Times(1)
+			},
+			userConnections: map[string]wsconnadapter.Adapter{},
+			connLock:        map[string]sync.Locker{},
+			expectedConn:    nil,
+		},
+		{
+			name: "Test GetConn returns nil if no connection for userID",
+			mock: func() {
+				mockLockMutex.EXPECT().Lock()
+				mockFooMutex.EXPECT().Lock()
+				mockLockMutex.EXPECT().Unlock()
+			},
+			connLock: map[string]sync.Locker{
+				"foo": mockFooMutex,
+			},
+			userConnections: map[string]wsconnadapter.Adapter{},
+			expectedConn:    nil,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			mockWsStore := wsstoreservice.NewWSStoreService(wsstoreservice.NewWsStoreServiceReq{
+				ConnLock:        tt.connLock,
+				LockMutex:       mockLockMutex,
+				UserConnections: tt.userConnections,
+			})
+
+			tt.mock()
+			conn := mockWsStore.GetConn("foo")
+			assert.Equal(t, tt.expectedConn, conn)
+		})
+	}
+}
+
+func TestRelease(t *testing.T) {
+	ctrl := gomock.NewController(t)
+
+	mockLockMutex := lockeradapter.NewMockLocker(ctrl)
+	mockFooMutex := lockeradapter.NewMockLocker(ctrl)
+	mockLock := map[string]sync.Locker{
+		"foo": mockFooMutex,
+	}
+
+	tests := []struct {
+		name string
+		mock func()
+	}{
+		{
+			name: "Test Release locks lockMutex and unlocks user mutex",
+			mock: func() {
+				mockLockMutex.EXPECT().Lock()
+				mockFooMutex.EXPECT().Unlock()
+				mockLockMutex.EXPECT().Unlock()
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			mockWsStore := wsstoreservice.NewWSStoreService(wsstoreservice.NewWsStoreServiceReq{
+				ConnLock:  mockLock,
+				LockMutex: mockLockMutex,
+			})
+
+			tt.mock()
+			mockWsStore.Release("foo")
+		})
+	}
+}