feat: use postgres

authsession/internal/adapters/redis/projectionpublisher/publisher_test.go

@@ -15,57 +15,51 @@ import (
 	"galaxy/authsession/internal/domain/gatewayprojection"
 
 	"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, server *miniredis.Miniredis) *redis.Client {
+	t.Helper()
+
+	client := redis.NewClient(&redis.Options{
+		Addr:            server.Addr(),
+		Protocol:        2,
+		DisableIdentity: true,
+	})
+	t.Cleanup(func() {
+		assert.NoError(t, client.Close())
+	})
+
+	return client
+}
+
 func TestNew(t *testing.T) {
 	t.Parallel()
 
 	server := miniredis.RunT(t)
+	client := newRedisClient(t, server)
+
+	validCfg := Config{
+		SessionCacheKeyPrefix: "gateway:session:",
+		SessionEventsStream:   "gateway:session_events",
+		StreamMaxLen:          1024,
+		OperationTimeout:      250 * time.Millisecond,
+	}
 
 	tests := []struct {
 		name    string
+		client  *redis.Client
 		cfg     Config
 		wantErr string
 	}{
+		{name: "valid config", client: client, cfg: validCfg},
+		{name: "nil client", client: nil, cfg: validCfg, wantErr: "nil redis client"},
 		{
-			name: "valid config",
+			name:   "empty session cache key prefix",
+			client: client,
 			cfg: Config{
-				Addr:                  server.Addr(),
-				DB:                    3,
-				SessionCacheKeyPrefix: "gateway:session:",
-				SessionEventsStream:   "gateway:session_events",
-				StreamMaxLen:          1024,
-				OperationTimeout:      250 * time.Millisecond,
-			},
-		},
-		{
-			name: "empty addr",
-			cfg: Config{
-				SessionCacheKeyPrefix: "gateway:session:",
-				SessionEventsStream:   "gateway:session_events",
-				StreamMaxLen:          1024,
-				OperationTimeout:      250 * time.Millisecond,
-			},
-			wantErr: "redis addr must not be empty",
-		},
-		{
-			name: "negative db",
-			cfg: Config{
-				Addr:                  server.Addr(),
-				DB:                    -1,
-				SessionCacheKeyPrefix: "gateway:session:",
-				SessionEventsStream:   "gateway:session_events",
-				StreamMaxLen:          1024,
-				OperationTimeout:      250 * time.Millisecond,
-			},
-			wantErr: "redis db must not be negative",
-		},
-		{
-			name: "empty session cache key prefix",
-			cfg: Config{
-				Addr:                server.Addr(),
 				SessionEventsStream: "gateway:session_events",
 				StreamMaxLen:        1024,
 				OperationTimeout:    250 * time.Millisecond,
@@ -73,9 +67,9 @@ func TestNew(t *testing.T) {
 			wantErr: "session cache key prefix must not be empty",
 		},
 		{
-			name: "empty session events stream",
+			name:   "empty session events stream",
+			client: client,
 			cfg: Config{
-				Addr:                  server.Addr(),
 				SessionCacheKeyPrefix: "gateway:session:",
 				StreamMaxLen:          1024,
 				OperationTimeout:      250 * time.Millisecond,
@@ -83,9 +77,9 @@ func TestNew(t *testing.T) {
 			wantErr: "session events stream must not be empty",
 		},
 		{
-			name: "non positive stream max len",
+			name:   "non positive stream max len",
+			client: client,
 			cfg: Config{
-				Addr:                  server.Addr(),
 				SessionCacheKeyPrefix: "gateway:session:",
 				SessionEventsStream:   "gateway:session_events",
 				OperationTimeout:      250 * time.Millisecond,
@@ -93,9 +87,9 @@ func TestNew(t *testing.T) {
 			wantErr: "stream max len must be positive",
 		},
 		{
-			name: "non positive timeout",
+			name:   "non positive timeout",
+			client: client,
 			cfg: Config{
-				Addr:                  server.Addr(),
 				SessionCacheKeyPrefix: "gateway:session:",
 				SessionEventsStream:   "gateway:session_events",
 				StreamMaxLen:          1024,
@@ -105,12 +99,10 @@ func TestNew(t *testing.T) {
 	}
 
 	for _, tt := range tests {
-		tt := tt
-
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 
-			publisher, err := New(tt.cfg)
+			publisher, err := New(tt.client, tt.cfg)
 			if tt.wantErr != "" {
 				require.Error(t, err)
 				assert.ErrorContains(t, err, tt.wantErr)
@@ -118,22 +110,11 @@ func TestNew(t *testing.T) {
 			}
 
 			require.NoError(t, err)
-			t.Cleanup(func() {
-				assert.NoError(t, publisher.Close())
-			})
+			require.NotNil(t, publisher)
 		})
 	}
 }
 
-func TestPublisherPing(t *testing.T) {
-	t.Parallel()
-
-	server := miniredis.RunT(t)
-	publisher := newTestPublisher(t, server, Config{})
-
-	require.NoError(t, publisher.Ping(context.Background()))
-}
-
 func TestPublisherPublishSessionActive(t *testing.T) {
 	t.Parallel()
 
@@ -331,23 +312,9 @@ func TestPublisherPublishSessionBackendFailure(t *testing.T) {
 	assert.ErrorContains(t, err, "publish session projection")
 }
 
-func TestPublisherPingNilContext(t *testing.T) {
-	t.Parallel()
-
-	server := miniredis.RunT(t)
-	publisher := newTestPublisher(t, server, Config{})
-
-	err := publisher.Ping(nil)
-	require.Error(t, err)
-	assert.ErrorContains(t, err, "nil context")
-}
-
 func newTestPublisher(t *testing.T, server *miniredis.Miniredis, cfg Config) *Publisher {
 	t.Helper()
 
-	if cfg.Addr == "" {
-		cfg.Addr = server.Addr()
-	}
 	if cfg.SessionCacheKeyPrefix == "" {
 		cfg.SessionCacheKeyPrefix = "gateway:session:"
 	}
@@ -361,11 +328,8 @@ func newTestPublisher(t *testing.T, server *miniredis.Miniredis, cfg Config) *Pu
 		cfg.OperationTimeout = 250 * time.Millisecond
 	}
 
-	publisher, err := New(cfg)
+	publisher, err := New(newRedisClient(t, server), cfg)
 	require.NoError(t, err)
-	t.Cleanup(func() {
-		assert.NoError(t, publisher.Close())
-	})
 
 	return publisher
 }