mock db connection with testfy golang

Question

Context

I have a simple gin based Rest API implementing CRUD over a redis DB. I want to mock the redis client (github.com/go-redis/redis/v9) in my unit tests. Coming from OOP, I feel that I am transposing some patterns wrongly.

Here is the route I want to test (internal/api.go)

func GetRouter() *gin.Engine {
    router := gin.Default()
    ...
    router.GET("/session/:sessionid", getSession)
    return router
}

Its controller is defined in internal/controlers.go

func getSession(c *gin.Context) {
    client := redis_client.GetClient()
    sessionid := c.Param("sessionid")
    val, err := client.Get(c, sessionid).Result()
    if err == redis.Nil {
        fmt.Printf("key %s not exist", sessionid)
        c.JSON(404, fmt.Sprintf("session %s not found", sessionid))
    } else if err != nil {
        fmt.Printf("unkown error %s", err)
        c.JSON(500, fmt.Sprintf(`{"error":"%s"}`, err))
    } else {
        c.JSON(200, val)
    }
}

redis_client.GetClient comes from one of my pkg. It's a singleton. pkg/redis/redis.go

var redisClient *redis.Client

func GetClient() *redis.Client {
    if redisClient == nil {
        redisClient = redis.NewClient(&redis.Options{
            Addr:     os.Getenv("REDIS_HOST"),
            Password: os.Getenv("REDIS_PWD"),
            DB:       0,                     
        })
    }
    return redisClient
}

Testing

Spontaneously, I tried to mock either redis.Client.Get or redis.StringCmd.Result, for it is the place where the actual call to Redis occurs. In both cases, I am using github.com/stretchr/testify/mock

Moking redis.Client.Get

import (
    ....
    "testing"
    "github.com/stretchr/testify/mock"
)

type MockedRedisConn struct {
    mock.Mock
}

func (m *MockedRedisConn) Get(ctx context.Context, key string) *redis.StringCmd {
    ret := m.Called(ctx, key)
    var r0 *redis.StringCmd
    if ret.Get(0) != nil {
        r0 = ret.Get(0).(*redis.StringCmd)
    }
    return r0
}

func Test_Sessions(t *testing.T) {
    r := api.GetRouter()
    redisConn := new(MockedRedisConn)
    var ctx = context.Background()
    t.Run("Should return the session", func(t *testing.T) {
        //mocks
        strCmd := redis.NewStringCmd(ctx)
        strCmd.SetVal(`{"session":""}`)
        redisConn.On("Get", mock.AnythingOfType("*gin.Context"), "00000000").Return(strCmd)

        //call
        req, _ := http.NewRequest("GET", "/session/00000000", nil)

        w := httptest.NewRecorder()
        r.ServeHTTP(w, req)

        responseData, _ := ioutil.ReadAll(w.Body)
        assert.Equal(t, `{"session":""}`, string(responseData))
        assert.Equal(t, http.StatusOK, w.Code)
    })
}

Same logic with redis.StringCmd.Result: I end up on a call to localhost:6379. What puzzles me is that, in most examples I could find, the mocked object is an argument of the function to be tested (I do not quite understand the point of it, by the way). In my case, it is not.

I typically miss a link to set the client in getSession to be my MockedRedisConn rather than the client given by GetClient() (i.e. some kind of monkey patching, if I am not mistaken). Is my singleton based setting of the client compatible with this approach? Should I rather load the client from *gin.Context so I could easily replace it when calling GetRouter in my tests?