feat: use postgres

2026-04-26 20:34:39 +02:00
parent 48b0056b49
commit fe829285a6
365 changed files with 29223 additions and 24049 deletions
@@ -4,7 +4,6 @@ package sendemailcodeabuse

 import (
 	"context"
-	"crypto/tls"
 	"encoding/base64"
 	"errors"
 	"fmt"
@@ -18,23 +17,10 @@ import (
 	"github.com/redis/go-redis/v9"
 )

-// Config configures one Redis-backed send-email-code abuse protector.
+// Config configures one Redis-backed send-email-code abuse protector. The
+// protector does not own its Redis client; the runtime supplies a shared
+// client constructed via `pkg/redisconn`.
 type Config struct {
-	// Addr is the Redis network address in host:port form.
-	Addr string
-
-	// Username is the optional Redis ACL username.
-	Username string
-
-	// Password is the optional Redis ACL password.
-	Password string
-
-	// DB is the Redis logical database index.
-	DB int
-
-	// TLSEnabled enables TLS with a conservative minimum protocol version.
-	TLSEnabled bool
-
 	// KeyPrefix is the namespace prefix applied to every resend-throttle key.
 	KeyPrefix string

@@ -50,63 +36,25 @@ type Protector struct {
 	operationTimeout time.Duration
 }

-// New constructs a Redis-backed resend-throttle protector from cfg.
-func New(cfg Config) (*Protector, error) {
+// New constructs a Redis-backed resend-throttle protector that uses client
+// and applies the namespace and timeout settings from cfg.
+func New(client *redis.Client, cfg Config) (*Protector, error) {
 	switch {
-	case strings.TrimSpace(cfg.Addr) == "":
-		return nil, errors.New("new redis send email code abuse protector: redis addr must not be empty")
-	case cfg.DB < 0:
-		return nil, errors.New("new redis send email code abuse protector: redis db must not be negative")
+	case client == nil:
+		return nil, errors.New("new redis send email code abuse protector: nil redis client")
 	case strings.TrimSpace(cfg.KeyPrefix) == "":
 		return nil, errors.New("new redis send email code abuse protector: redis key prefix must not be empty")
 	case cfg.OperationTimeout <= 0:
 		return nil, errors.New("new redis send email code abuse protector: operation timeout must be positive")
 	}

-	options := &redis.Options{
-		Addr:            cfg.Addr,
-		Username:        cfg.Username,
-		Password:        cfg.Password,
-		DB:              cfg.DB,
-		Protocol:        2,
-		DisableIdentity: true,
-	}
-	if cfg.TLSEnabled {
-		options.TLSConfig = &tls.Config{MinVersion: tls.VersionTLS12}
-	}
-
 	return &Protector{
-		client:           redis.NewClient(options),
+		client:           client,
 		keyPrefix:        cfg.KeyPrefix,
 		operationTimeout: cfg.OperationTimeout,
 	}, nil
 }

-// Close releases the underlying Redis client resources.
-func (p *Protector) Close() error {
-	if p == nil || p.client == nil {
-		return nil
-	}
-
-	return p.client.Close()
-}
-
-// Ping verifies that the configured Redis backend is reachable within the
-// adapter operation timeout budget.
-func (p *Protector) Ping(ctx context.Context) error {
-	operationCtx, cancel, err := p.operationContext(ctx, "ping redis send email code abuse protector")
-	if err != nil {
-		return err
-	}
-	defer cancel()
-
-	if err := p.client.Ping(operationCtx).Err(); err != nil {
-		return fmt.Errorf("ping redis send email code abuse protector: %w", err)
-	}
-
-	return nil
-}
-
 // CheckAndReserve applies the fixed resend cooldown using one TTL key per
 // normalized e-mail address.
 func (p *Protector) CheckAndReserve(ctx context.Context, input ports.SendEmailCodeAbuseInput) (ports.SendEmailCodeAbuseResult, error) {
@@ -10,72 +10,64 @@ import (
 	"galaxy/authsession/internal/ports"

 	"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{
+		KeyPrefix:        "authsession:send-email-code-throttle:",
+		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",
-			cfg: Config{
-				Addr:             server.Addr(),
-				DB:               1,
-				KeyPrefix:        "authsession:send-email-code-throttle:",
-				OperationTimeout: 250 * time.Millisecond,
-			},
-		},
-		{
-			name: "empty addr",
-			cfg: Config{
-				KeyPrefix:        "authsession:send-email-code-throttle:",
-				OperationTimeout: 250 * time.Millisecond,
-			},
-			wantErr: "redis addr must not be empty",
-		},
-		{
-			name: "negative db",
-			cfg: Config{
-				Addr:             server.Addr(),
-				DB:               -1,
-				KeyPrefix:        "authsession:send-email-code-throttle:",
-				OperationTimeout: 250 * time.Millisecond,
-			},
-			wantErr: "redis db must not be negative",
-		},
-		{
-			name: "empty key prefix",
-			cfg: Config{
-				Addr:             server.Addr(),
-				OperationTimeout: 250 * time.Millisecond,
-			},
+			name:    "empty key prefix",
+			client:  client,
+			cfg:     Config{OperationTimeout: 250 * time.Millisecond},
 			wantErr: "redis key prefix must not be empty",
 		},
 		{
-			name: "non-positive timeout",
-			cfg: Config{
-				Addr:      server.Addr(),
-				KeyPrefix: "authsession:send-email-code-throttle:",
-			},
+			name:    "non-positive timeout",
+			client:  client,
+			cfg:     Config{KeyPrefix: "authsession:send-email-code-throttle:"},
 			wantErr: "operation timeout must be positive",
 		},
 	}

 	for _, tt := range tests {
-		tt := tt
-
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()

-			protector, err := New(tt.cfg)
+			protector, err := New(tt.client, tt.cfg)
 			if tt.wantErr != "" {
 				require.Error(t, err)
 				assert.ErrorContains(t, err, tt.wantErr)
@@ -83,22 +75,11 @@ func TestNew(t *testing.T) {
 			}

 			require.NoError(t, err)
-			t.Cleanup(func() {
-				assert.NoError(t, protector.Close())
-			})
+			require.NotNil(t, protector)
 		})
 	}
 }

-func TestProtectorPing(t *testing.T) {
-	t.Parallel()
-
-	server := miniredis.RunT(t)
-	protector := newTestProtector(t, server, Config{})
-
-	require.NoError(t, protector.Ping(context.Background()))
-}
-
 func TestProtectorCheckAndReserve(t *testing.T) {
 	t.Parallel()

@@ -156,9 +137,6 @@ func TestProtectorNilContext(t *testing.T) {
 func newTestProtector(t *testing.T, server *miniredis.Miniredis, cfg Config) *Protector {
 	t.Helper()

-	if cfg.Addr == "" {
-		cfg.Addr = server.Addr()
-	}
 	if cfg.KeyPrefix == "" {
 		cfg.KeyPrefix = "authsession:send-email-code-throttle:"
 	}
@@ -166,11 +144,8 @@ func newTestProtector(t *testing.T, server *miniredis.Miniredis, cfg Config) *Pr
 		cfg.OperationTimeout = 250 * time.Millisecond
 	}

-	protector, err := New(cfg)
+	protector, err := New(newRedisClient(t, server), cfg)
 	require.NoError(t, err)
-	t.Cleanup(func() {
-		assert.NoError(t, protector.Close())
-	})

 	return protector
 }