tests: add tests for redis kv (#72)

* tests: add tests for redis kv

* chore: Updated coverage badge.

---------

Co-authored-by: GitHub Action <[email protected]>

Author: Abhishekvrshny

Readme.md

@@ -1,5 +1,5 @@
 # Propeller 𖣘
-![Coverage](https://img.shields.io/badge/Coverage-12.0%25-red)
+![Coverage](https://img.shields.io/badge/Coverage-12.3%25-red)
 [![Go Report Card](https://goreportcard.com/badge/github.com/CRED-CLUB/propeller)](https://goreportcard.com/report/github.com/CRED-CLUB/propeller)
 [![CHECKS](https://github.com/CRED-CLUB/propeller/actions/workflows/checks.yaml/badge.svg)](https://github.com/CRED-CLUB/propeller/actions/workflows/checks.yaml/badge.svg)
 [![GoDoc](https://godoc.org/github.com/CRED-CLUB/propeller?status.svg)](https://godoc.org/github.com/CRED-CLUB/propeller) <a href="https://starcharts.herokuapp.com/CRED-CLUB/propeller"><img alt="Stars" src="https://img.shields.io/github/stars/CRED-CLUB/propeller.svg?style=social"></a>

internal/kv/redis.go

@@ -6,13 +6,13 @@ import (
 	redispkg "github.com/CRED-CLUB/propeller/pkg/broker/redis"
 )
 
-// Redis ...
+// Redis implements IKV interface using Redis
 type Redis struct {
-	redisClient *redispkg.Client
+	redisClient redispkg.IKVClient
 }
 
 // NewRedis returns redis kv client
-func NewRedis(client *redispkg.Client) IKV {
+func NewRedis(client redispkg.IKVClient) IKV {
 	return &Redis{client}
 }
 

internal/kv/redis_test.go

@@ -0,0 +1,173 @@
+package kv
+
+import (
+	"context"
+	"errors"
+	"testing"
+
+	redispkg "github.com/CRED-CLUB/propeller/pkg/broker/redis"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+)
+
+// Define a common error for testing
+var errTestFailed = errors.New("test error")
+
+// MockRedisClient is a mock implementation of the redispkg.IKVClient interface
+type MockRedisClient struct {
+	mock.Mock
+}
+
+// Ensure MockRedisClient implements redispkg.IKVClient
+var _ redispkg.IKVClient = (*MockRedisClient)(nil)
+
+func (m *MockRedisClient) HSet(ctx context.Context, key string, values ...interface{}) error {
+	args := m.Called(ctx, key, values)
+	return args.Error(0)
+}
+
+func (m *MockRedisClient) HGetAll(ctx context.Context, key string) (map[string]string, error) {
+	args := m.Called(ctx, key)
+	return args.Get(0).(map[string]string), args.Error(1)
+}
+
+func (m *MockRedisClient) Delete(ctx context.Context, key string, fields ...string) error {
+	args := m.Called(ctx, key, fields)
+	return args.Error(0)
+}
+
+func TestNewRedis(t *testing.T) {
+	mockClient := new(MockRedisClient)
+	redis := NewRedis(mockClient)
+
+	assert.NotNil(t, redis)
+	assert.Implements(t, (*IKV)(nil), redis)
+
+	// Type assertion to verify the internal client is set correctly
+	redisImpl, ok := redis.(*Redis)
+	assert.True(t, ok)
+	assert.Equal(t, mockClient, redisImpl.redisClient)
+}
+
+func TestRedis_Store(t *testing.T) {
+	ctx := context.Background()
+
+	t.Run("successful store", func(t *testing.T) {
+		mockClient := new(MockRedisClient)
+		redis := NewRedis(mockClient)
+
+		// The Redis implementation will call HSet with field and value as separate arguments
+		mockClient.On("HSet", ctx, "test-key", []interface{}{"field1", "value1"}).Return(nil).Once()
+
+		err := redis.Store(ctx, "test-key", "field1", "value1")
+
+		assert.NoError(t, err)
+		mockClient.AssertExpectations(t)
+	})
+
+	t.Run("error on store", func(t *testing.T) {
+		mockClient := new(MockRedisClient)
+		redis := NewRedis(mockClient)
+
+		mockClient.On("HSet", ctx, "test-key", []interface{}{"field1", "value1"}).Return(errTestFailed).Once()
+
+		err := redis.Store(ctx, "test-key", "field1", "value1")
+
+		assert.Error(t, err)
+		assert.Equal(t, errTestFailed, err)
+		mockClient.AssertExpectations(t)
+	})
+}
+
+func TestRedis_Load(t *testing.T) {
+	ctx := context.Background()
+
+	t.Run("successful load with data", func(t *testing.T) {
+		mockClient := new(MockRedisClient)
+		redis := NewRedis(mockClient)
+
+		expectedData := map[string]string{
+			"field1": "value1",
+			"field2": "value2",
+		}
+
+		mockClient.On("HGetAll", ctx, "test-key").Return(expectedData, nil).Once()
+
+		result, err := redis.Load(ctx, "test-key")
+
+		assert.NoError(t, err)
+		assert.Equal(t, expectedData, result)
+		mockClient.AssertExpectations(t)
+	})
+
+	t.Run("successful load with empty data", func(t *testing.T) {
+		mockClient := new(MockRedisClient)
+		redis := NewRedis(mockClient)
+
+		expectedData := map[string]string{}
+
+		mockClient.On("HGetAll", ctx, "test-key").Return(expectedData, nil).Once()
+
+		result, err := redis.Load(ctx, "test-key")
+
+		assert.NoError(t, err)
+		assert.Empty(t, result)
+		mockClient.AssertExpectations(t)
+	})
+
+	t.Run("error on load", func(t *testing.T) {
+		mockClient := new(MockRedisClient)
+		redis := NewRedis(mockClient)
+
+		mockClient.On("HGetAll", ctx, "test-key").Return(map[string]string(nil), errTestFailed).Once()
+
+		result, err := redis.Load(ctx, "test-key")
+
+		assert.Error(t, err)
+		assert.Equal(t, errTestFailed, err)
+		assert.Nil(t, result)
+		mockClient.AssertExpectations(t)
+	})
+}
+
+func TestRedis_Delete(t *testing.T) {
+	ctx := context.Background()
+
+	t.Run("successful delete single field", func(t *testing.T) {
+		mockClient := new(MockRedisClient)
+		redis := NewRedis(mockClient)
+
+		mockClient.On("Delete", ctx, "test-key", []string{"field1"}).Return(nil).Once()
+
+		err := redis.Delete(ctx, "test-key", "field1")
+
+		assert.NoError(t, err)
+		mockClient.AssertExpectations(t)
+	})
+
+	t.Run("successful delete multiple fields", func(t *testing.T) {
+		mockClient := new(MockRedisClient)
+		redis := NewRedis(mockClient)
+
+		fields := []string{"field1", "field2"}
+		mockClient.On("Delete", ctx, "test-key", fields).Return(nil).Once()
+
+		err := redis.Delete(ctx, "test-key", fields...)
+
+		assert.NoError(t, err)
+		mockClient.AssertExpectations(t)
+	})
+
+	t.Run("error on delete", func(t *testing.T) {
+		mockClient := new(MockRedisClient)
+		redis := NewRedis(mockClient)
+
+		mockClient.On("Delete", ctx, "test-key", []string{"field1"}).Return(errTestFailed).Once()
+
+		err := redis.Delete(ctx, "test-key", "field1")
+
+		assert.Error(t, err)
+		assert.Equal(t, errTestFailed, err)
+		mockClient.AssertExpectations(t)
+	})
+}

pkg/broker/redis/redis.go

@@ -21,11 +21,21 @@ type IRedis interface {
 	RemoveSubscription(ctx context.Context, channel string, s broker.ISubscription) error
 }
 
-// Client holds redis client
+// IKVClient defines the interface for Redis key-value operations
+type IKVClient interface {
+	HSet(ctx context.Context, key string, values ...interface{}) error
+	HGetAll(ctx context.Context, key string) (map[string]string, error)
+	Delete(ctx context.Context, key string, fields ...string) error
+}
+
+// Client holds redis client and implements IKVClient
 type Client struct {
 	client redis.UniversalClient
 }
 
+// Ensure Client implements IKVClient
+var _ IKVClient = (*Client)(nil)
+
 // NewClient returns a new redis client
 func NewClient(config Config) *Client {
 	var tlsConfig *tls.Config = nil