eric/onix
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial Commit of Redis Plugin with Unit Test cases

Browse Source
This commit is contained in:
Atharva Zade
2025-05-13 16:47:34 +05:30
parent 21e823b955
commit 1b79156693
3 changed files with 167 additions and 64 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
pkg/plugin/implementation/cache/cache.go vendored
View File

@@ -10,6 +10,9 @@ import (
"github.com/redis/go-redis/v9"
)
// Global variable for the Redis client, can be overridden in tests
var RedisCl *redis.Client
// RedisClient is an interface for Redis operations that allows mocking
type RedisClient interface {
Get(ctx context.Context, key string) *redis.StringCmd
@@ -17,6 +20,7 @@ type RedisClient interface {
Del(ctx context.Context, keys ...string) *redis.IntCmd
FlushDB(ctx context.Context) *redis.StatusCmd
Ping(ctx context.Context) *redis.StatusCmd
Close() error
}
type Config struct {
@@ -24,7 +28,7 @@ type Config struct {
}
type Cache struct {
client RedisClient
Client RedisClient
}
var (
@@ -44,38 +48,40 @@ func validate(cfg *Config) error {
return nil
}
var RedisClientFunc = func(cfg *Config) RedisClient {
return redis.NewClient(&redis.Options{
Addr: cfg.Addr,
Password: os.Getenv("REDIS_PASSWORD"),
DB: 0,
})
}
func New(ctx context.Context, cfg *Config) (*Cache, func() error, error) {
if err := validate(cfg); err != nil {
return nil, nil, err
}
password := os.Getenv("REDIS_PASSWORD")
client := redis.NewClient(&redis.Options{
Addr: cfg.Addr,
Password: password,
DB: 0, // Always use default DB 0
})
client := RedisClientFunc(cfg)
if _, err := client.Ping(ctx).Result(); err != nil {
return nil, nil, fmt.Errorf("%w: %v", ErrConnectionFail, err)
}
return &Cache{client: client}, client.Close, nil
return &Cache{Client: client}, client.Close, nil
}
func (c *Cache) Get(ctx context.Context, key string) (string, error) {
return c.client.Get(ctx, key).Result()
return c.Client.Get(ctx, key).Result()
}
func (c *Cache) Set(ctx context.Context, key, value string, ttl time.Duration) error {
return c.client.Set(ctx, key, value, ttl).Err()
return c.Client.Set(ctx, key, value, ttl).Err()
}
func (c *Cache) Delete(ctx context.Context, key string) error {
return c.client.Del(ctx, key).Err()
return c.Client.Del(ctx, key).Err()
}
func (c *Cache) Clear(ctx context.Context) error {
return c.client.FlushDB(ctx).Err()
return c.Client.FlushDB(ctx).Err()
}

15
pkg/plugin/implementation/cache/cache_test.go vendored
View File

@@ -41,11 +41,16 @@ func (m *MockRedisClient) Ping(ctx context.Context) *redis.StatusCmd {
return args.Get(0).(*redis.StatusCmd)
}
func (m *MockRedisClient) Close() error {
args := m.Called()
return args.Error(0)
}
// TestCache_Get tests the Get method of the Cache type
func TestCache_Get(t *testing.T) {
mockClient := new(MockRedisClient)
ctx := context.Background()
cache := &Cache{client: mockClient}
cache := &Cache{Client: mockClient}
mockClient.On("Get", ctx, "my-key").Return("my-value", nil)
@@ -59,7 +64,7 @@ func TestCache_Get(t *testing.T) {
func TestCache_Set(t *testing.T) {
mockClient := new(MockRedisClient)
ctx := context.Background()
cache := &Cache{client: mockClient}
cache := &Cache{Client: mockClient}
mockClient.On("Set", ctx, "my-key", "my-value", time.Minute).Return("OK", nil)
@@ -72,7 +77,7 @@ func TestCache_Set(t *testing.T) {
func TestCache_Delete(t *testing.T) {
mockClient := new(MockRedisClient)
ctx := context.Background()
cache := &Cache{client: mockClient}
cache := &Cache{Client: mockClient}
mockClient.On("Del", ctx, []string{"my-key"}).Return(1, nil)
@@ -85,7 +90,7 @@ func TestCache_Delete(t *testing.T) {
func TestCache_Clear(t *testing.T) {
mockClient := new(MockRedisClient)
ctx := context.Background()
cache := &Cache{client: mockClient}
cache := &Cache{Client: mockClient}
mockClient.On("FlushDB", ctx).Return("OK", nil)
@@ -175,7 +180,7 @@ func TestNew_ConnectionFailure(t *testing.T) {
if err != nil {
t.Fatalf("Failed to set REDIS_PASSWORD environment variable: %v", err)
}
defer func() {
err := os.Unsetenv("REDIS_PASSWORD")
if err != nil {

184
pkg/plugin/implementation/cache/cmd/plugin_test.go vendored
View File

@@ -4,8 +4,12 @@ import (
"context"
"os"
"testing"
"time"
"github.com/beckn/beckn-onix/pkg/plugin/implementation/cache"
"github.com/redis/go-redis/v9"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/mock"
)
// TestParseConfig tests the configuration parsing logic of the plugin
@@ -135,61 +139,149 @@ func TestProviderNew(t *testing.T) {
}
// TestProviderIntegration tests the provider with a real Redis server
func TestProviderIntegration(t *testing.T) {
// Skip this test if requested
if os.Getenv("SKIP_REDIS_INTEGRATION_TEST") == "true" {
t.Skip("Integration test skipped - SKIP_REDIS_INTEGRATION_TEST=true")
}
// func TestProviderIntegration(t *testing.T) {
// // Skip this test if requested
// if os.Getenv("SKIP_REDIS_INTEGRATION_TEST") == "true" {
// t.Skip("Integration test skipped - SKIP_REDIS_INTEGRATION_TEST=true")
// }
// Set an empty password for testing
if err := os.Setenv("REDIS_PASSWORD", ""); err != nil {
t.Fatalf("Failed to set REDIS_PASSWORD: %v", err)
}
// Ensure we clean up the environment variable at the end
defer func() {
if err := os.Unsetenv("REDIS_PASSWORD"); err != nil {
t.Fatalf("Failed to unset REDIS_PASSWORD: %v", err)
}
}()
// // Set an empty password for testing
// if err := os.Setenv("REDIS_PASSWORD", ""); err != nil {
// t.Fatalf("Failed to set REDIS_PASSWORD: %v", err)
// }
// Create provider and test with real Redis
provider := cacheProvider{}
ctx := context.Background()
config := map[string]string{
"addr": "localhost:6379",
"db": "0",
}
// // Ensure we clean up the environment variable at the end
// defer func() {
// if err := os.Unsetenv("REDIS_PASSWORD"); err != nil {
// t.Fatalf("Failed to unset REDIS_PASSWORD: %v", err)
// }
// }()
cache, cleanup, err := provider.New(ctx, config)
if err != nil {
t.Fatalf("Failed to create cache: %v", err)
}
defer func() {
if err := cleanup(); err != nil {
t.Fatalf("Failed to clean up Redis client: %v", err)
}
}()
// // Create provider and test with real Redis
// provider := cacheProvider{}
// ctx := context.Background()
// config := map[string]string{
// "addr": "localhost:6379",
// "db": "0",
// }
// Verify it works by setting and getting a value
testKey := "provider_test_key"
testValue := "provider_test_value"
// cache, cleanup, err := provider.New(ctx, config)
// if err != nil {
// t.Fatalf("Failed to create cache: %v", err)
// }
// defer func() {
// if err := cleanup(); err != nil {
// t.Fatalf("Failed to clean up Redis client: %v", err)
// }
// }()
// Set a value
err = cache.Set(ctx, testKey, testValue, 0)
assert.NoError(t, err, "Set operation should not fail")
// // Verify it works by setting and getting a value
// testKey := "provider_test_key"
// testValue := "provider_test_value"
// Get the value
got, err := cache.Get(ctx, testKey)
assert.NoError(t, err, "Get operation should not fail")
assert.Equal(t, testValue, got, "Should get the value that was set")
// // Set a value
// err = cache.Set(ctx, testKey, testValue, 0)
// assert.NoError(t, err, "Set operation should not fail")
// Clean up
err = cache.Delete(ctx, testKey)
assert.NoError(t, err, "Delete operation should not fail")
}
// // Get the value
// got, err := cache.Get(ctx, testKey)
// assert.NoError(t, err, "Get operation should not fail")
// assert.Equal(t, testValue, got, "Should get the value that was set")
// // Clean up
// err = cache.Delete(ctx, testKey)
// assert.NoError(t, err, "Delete operation should not fail")
// }
// TestProviderVariable tests that the Provider variable is correctly initialized
func TestProviderVariable(t *testing.T) {
assert.NotNil(t, Provider, "Provider should not be nil")
}
// mockRedisClient mocks the RedisClient interface from the cache package
type mockRedisClient struct {
mock.Mock
}
func (m *mockRedisClient) Get(ctx context.Context, key string) *redis.StringCmd {
args := m.Called(ctx, key)
cmd := redis.NewStringCmd(ctx)
cmd.SetVal(args.String(0))
return cmd
}
func (m *mockRedisClient) Set(ctx context.Context, key string, value interface{}, ttl time.Duration) *redis.StatusCmd {
args := m.Called(ctx, key, value, ttl)
cmd := redis.NewStatusCmd(ctx)
cmd.SetVal(args.String(0))
return cmd
}
func (m *mockRedisClient) Del(ctx context.Context, keys ...string) *redis.IntCmd {
args := m.Called(ctx, keys)
cmd := redis.NewIntCmd(ctx)
cmd.SetVal(int64(args.Int(0)))
return cmd
}
func (m *mockRedisClient) FlushDB(ctx context.Context) *redis.StatusCmd {
args := m.Called(ctx)
cmd := redis.NewStatusCmd(ctx)
cmd.SetVal(args.String(0))
return cmd
}
func (m *mockRedisClient) Ping(ctx context.Context) *redis.StatusCmd {
args := m.Called(ctx)
cmd := redis.NewStatusCmd(ctx)
cmd.SetVal(args.String(0))
return cmd
}
func (m *mockRedisClient) Close() error {
args := m.Called()
return args.Error(0)
}
func TestProviderIntegration(t *testing.T) {
// Save original RedisClientFunc and restore after test
original := cache.RedisClientFunc
defer func() { cache.RedisClientFunc = original }()
// Create and assign mock
mockClient := new(mockRedisClient)
cache.RedisClientFunc = func(cfg *cache.Config) cache.RedisClient {
return mockClient
}
ctx := context.Background()
// Expectations for the mock
mockClient.On("Ping", ctx).Return("PONG")
mockClient.On("Close").Return(nil)
// Create the config and convert it into a map[string]string
config := &cache.Config{
Addr: "localhost:35",
}
// Convert the *cache.Config to map[string]string
configMap := map[string]string{
"addr": config.Addr,
}
// Call the plugin provider
provider := Provider
c, cleanup, err := provider.New(ctx, configMap)
// Assertions
assert.NoError(t, err)
assert.NotNil(t, c)
assert.NotNil(t, cleanup)
// Call cleanup and assert
err = cleanup()
assert.NoError(t, err)
// Verify expectations
mockClient.AssertExpectations(t)
}