feat: use postgres

gateway/internal/replay/redis_test.go

@@ -10,81 +10,64 @@ import (
 	"galaxy/gateway/internal/config"
 
 	"github.com/alicebob/miniredis/v2"
+	"github.com/redis/go-redis/v9"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
+func newRedisClient(t *testing.T, addr string) *redis.Client {
+	t.Helper()
+
+	client := redis.NewClient(&redis.Options{
+		Addr:            addr,
+		Protocol:        2,
+		DisableIdentity: true,
+	})
+	t.Cleanup(func() {
+		assert.NoError(t, client.Close())
+	})
+
+	return client
+}
+
 func TestNewRedisStore(t *testing.T) {
 	t.Parallel()
 
 	server := miniredis.RunT(t)
+	client := newRedisClient(t, server.Addr())
+
+	validCfg := config.ReplayRedisConfig{
+		KeyPrefix:      "gateway:replay:",
+		ReserveTimeout: 250 * time.Millisecond,
+	}
 
 	tests := []struct {
-		name       string
-		sessionCfg config.SessionCacheRedisConfig
-		replayCfg  config.ReplayRedisConfig
-		wantErr    string
+		name    string
+		client  *redis.Client
+		cfg     config.ReplayRedisConfig
+		wantErr string
 	}{
+		{name: "valid config", client: client, cfg: validCfg},
+		{name: "nil client", client: nil, cfg: validCfg, wantErr: "nil redis client"},
 		{
-			name: "valid config",
-			sessionCfg: config.SessionCacheRedisConfig{
-				Addr: server.Addr(),
-				DB:   2,
-			},
-			replayCfg: config.ReplayRedisConfig{
-				KeyPrefix:      "gateway:replay:",
-				ReserveTimeout: 250 * time.Millisecond,
-			},
-		},
-		{
-			name: "empty redis addr",
-			replayCfg: config.ReplayRedisConfig{
-				KeyPrefix:      "gateway:replay:",
-				ReserveTimeout: 250 * time.Millisecond,
-			},
-			wantErr: "redis addr must not be empty",
-		},
-		{
-			name: "negative redis db",
-			sessionCfg: config.SessionCacheRedisConfig{
-				Addr: server.Addr(),
-				DB:   -1,
-			},
-			replayCfg: config.ReplayRedisConfig{
-				KeyPrefix:      "gateway:replay:",
-				ReserveTimeout: 250 * time.Millisecond,
-			},
-			wantErr: "redis db must not be negative",
-		},
-		{
-			name: "empty replay key prefix",
-			sessionCfg: config.SessionCacheRedisConfig{
-				Addr: server.Addr(),
-			},
-			replayCfg: config.ReplayRedisConfig{
-				ReserveTimeout: 250 * time.Millisecond,
-			},
+			name:    "empty replay key prefix",
+			client:  client,
+			cfg:     config.ReplayRedisConfig{ReserveTimeout: 250 * time.Millisecond},
 			wantErr: "replay key prefix must not be empty",
 		},
 		{
-			name: "non-positive reserve timeout",
-			sessionCfg: config.SessionCacheRedisConfig{
-				Addr: server.Addr(),
-			},
-			replayCfg: config.ReplayRedisConfig{
-				KeyPrefix: "gateway:replay:",
-			},
+			name:    "non-positive reserve timeout",
+			client:  client,
+			cfg:     config.ReplayRedisConfig{KeyPrefix: "gateway:replay:"},
 			wantErr: "reserve timeout must be positive",
 		},
 	}
 
 	for _, tt := range tests {
-		tt := tt
-
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 
-			store, err := NewRedisStore(tt.sessionCfg, tt.replayCfg)
+			store, err := NewRedisStore(tt.client, tt.cfg)
 			if tt.wantErr != "" {
 				require.Error(t, err)
 				require.ErrorContains(t, err, tt.wantErr)
@@ -92,28 +75,16 @@ func TestNewRedisStore(t *testing.T) {
 			}
 
 			require.NoError(t, err)
-			t.Cleanup(func() {
-				assert.NoError(t, store.Close())
-			})
+			require.NotNil(t, store)
 		})
 	}
 }
 
-func TestRedisStorePing(t *testing.T) {
-	t.Parallel()
-
-	server := miniredis.RunT(t)
-	store := newTestRedisStore(t, server, config.SessionCacheRedisConfig{}, config.ReplayRedisConfig{})
-
-	require.NoError(t, store.Ping(context.Background()))
-}
-
 func TestRedisStoreReserve(t *testing.T) {
 	t.Parallel()
 
 	tests := []struct {
 		name            string
-		sessionCfg      config.SessionCacheRedisConfig
 		replayCfg       config.ReplayRedisConfig
 		deviceSessionID string
 		requestID       string
@@ -170,13 +141,11 @@ func TestRedisStoreReserve(t *testing.T) {
 	}
 
 	for _, tt := range tests {
-		tt := tt
-
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 
 			server := miniredis.RunT(t)
-			store := newTestRedisStore(t, server, tt.sessionCfg, tt.replayCfg)
+			store := newTestRedisStore(t, server, tt.replayCfg)
 
 			err := store.Reserve(context.Background(), tt.deviceSessionID, tt.requestID, tt.ttl)
 			if tt.wantErrIs != nil || tt.wantErrText != "" {
@@ -201,17 +170,12 @@ func TestRedisStoreReserve(t *testing.T) {
 func TestRedisStoreReserveReturnsBackendError(t *testing.T) {
 	t.Parallel()
 
-	store, err := NewRedisStore(
-		config.SessionCacheRedisConfig{Addr: unusedTCPAddr(t)},
-		config.ReplayRedisConfig{
-			KeyPrefix:      "gateway:replay:",
-			ReserveTimeout: 100 * time.Millisecond,
-		},
-	)
-	require.NoError(t, err)
-	t.Cleanup(func() {
-		assert.NoError(t, store.Close())
+	client := newRedisClient(t, unusedTCPAddr(t))
+	store, err := NewRedisStore(client, config.ReplayRedisConfig{
+		KeyPrefix:      "gateway:replay:",
+		ReserveTimeout: 100 * time.Millisecond,
 	})
+	require.NoError(t, err)
 
 	err = store.Reserve(context.Background(), "device-session-123", "request-123", 5*time.Second)
 	require.Error(t, err)
@@ -219,12 +183,9 @@ func TestRedisStoreReserveReturnsBackendError(t *testing.T) {
 	assert.ErrorContains(t, err, "reserve replay request in redis")
 }
 
-func newTestRedisStore(t *testing.T, server *miniredis.Miniredis, sessionCfg config.SessionCacheRedisConfig, replayCfg config.ReplayRedisConfig) *RedisStore {
+func newTestRedisStore(t *testing.T, server *miniredis.Miniredis, replayCfg config.ReplayRedisConfig) *RedisStore {
 	t.Helper()
 
-	if sessionCfg.Addr == "" {
-		sessionCfg.Addr = server.Addr()
-	}
 	if replayCfg.KeyPrefix == "" {
 		replayCfg.KeyPrefix = "gateway:replay:"
 	}
@@ -232,11 +193,8 @@ func newTestRedisStore(t *testing.T, server *miniredis.Miniredis, sessionCfg con
 		replayCfg.ReserveTimeout = 250 * time.Millisecond
 	}
 
-	store, err := NewRedisStore(sessionCfg, replayCfg)
+	store, err := NewRedisStore(newRedisClient(t, server.Addr()), replayCfg)
 	require.NoError(t, err)
-	t.Cleanup(func() {
-		assert.NoError(t, store.Close())
-	})
 
 	return store
 }