Ilia Denisov
253 lines
10 KiB
Go
253 lines
10 KiB
Go
package config
|
|
|
|
import (
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func TestLoadFromEnvUsesDefaults(t *testing.T) {
|
|
t.Setenv(redisAddrEnvVar, "127.0.0.1:6379")
|
|
t.Setenv(userServiceBaseURLEnvVar, "http://user-service.internal")
|
|
|
|
cfg, err := LoadFromEnv()
|
|
require.NoError(t, err)
|
|
|
|
defaults := DefaultConfig()
|
|
require.Equal(t, defaults.ShutdownTimeout, cfg.ShutdownTimeout)
|
|
require.Equal(t, defaults.Logging, cfg.Logging)
|
|
require.Equal(t, defaults.InternalHTTP, cfg.InternalHTTP)
|
|
require.Equal(t, "127.0.0.1:6379", cfg.Redis.Addr)
|
|
require.Equal(t, defaults.Redis.DB, cfg.Redis.DB)
|
|
require.Equal(t, defaults.Redis.OperationTimeout, cfg.Redis.OperationTimeout)
|
|
require.Equal(t, defaults.Streams, cfg.Streams)
|
|
require.Equal(t, defaults.Retry, cfg.Retry)
|
|
require.Equal(t, UserServiceConfig{
|
|
BaseURL: "http://user-service.internal",
|
|
Timeout: defaults.UserService.Timeout,
|
|
}, cfg.UserService)
|
|
require.Equal(t, defaults.AdminRouting, cfg.AdminRouting)
|
|
require.Equal(t, defaults.Telemetry, cfg.Telemetry)
|
|
}
|
|
|
|
func TestLoadFromEnvAppliesOverrides(t *testing.T) {
|
|
t.Setenv(shutdownTimeoutEnvVar, "9s")
|
|
t.Setenv(logLevelEnvVar, "debug")
|
|
t.Setenv(internalHTTPAddrEnvVar, "127.0.0.1:18092")
|
|
t.Setenv(internalHTTPReadHeaderTimeoutEnvVar, "3s")
|
|
t.Setenv(internalHTTPReadTimeoutEnvVar, "11s")
|
|
t.Setenv(internalHTTPIdleTimeoutEnvVar, "61s")
|
|
t.Setenv(redisAddrEnvVar, "127.0.0.1:6380")
|
|
t.Setenv(redisUsernameEnvVar, "alice")
|
|
t.Setenv(redisPasswordEnvVar, "secret")
|
|
t.Setenv(redisDBEnvVar, "3")
|
|
t.Setenv(redisTLSEnabledEnvVar, "true")
|
|
t.Setenv(redisOperationTimeoutEnvVar, "750ms")
|
|
t.Setenv(intentsStreamEnvVar, "notification:test_intents")
|
|
t.Setenv(intentsReadBlockTimeoutEnvVar, "3500ms")
|
|
t.Setenv(gatewayClientEventsStreamEnvVar, "gateway:test_client-events")
|
|
t.Setenv(gatewayClientEventsStreamMaxEnvVar, "2048")
|
|
t.Setenv(mailDeliveryCommandsStreamEnvVar, "mail:test_delivery_commands")
|
|
t.Setenv(pushRetryMaxAttemptsEnvVar, "5")
|
|
t.Setenv(emailRetryMaxAttemptsEnvVar, "9")
|
|
t.Setenv(routeLeaseTTLEnvVar, "7s")
|
|
t.Setenv(routeBackoffMinEnvVar, "2s")
|
|
t.Setenv(routeBackoffMaxEnvVar, "7m")
|
|
t.Setenv(deadLetterTTLEnvVar, "120h")
|
|
t.Setenv(recordTTLEnvVar, "240h")
|
|
t.Setenv(idempotencyTTLEnvVar, "48h")
|
|
t.Setenv(userServiceBaseURLEnvVar, "https://user-service.internal/api/")
|
|
t.Setenv(userServiceTimeoutEnvVar, "1500ms")
|
|
t.Setenv(adminEmailsGeoReviewRecommendedEnvVar, "First@example.com, second@example.com, first@example.com")
|
|
t.Setenv(adminEmailsGameGenerationFailedEnvVar, "ops@example.com")
|
|
t.Setenv(adminEmailsLobbyRuntimePausedAfterEnvVar, "pause@example.com, PAUSE@example.com")
|
|
t.Setenv(adminEmailsLobbyApplicationSubmittedEnvVar, "owner@example.com, OWNER@example.com")
|
|
t.Setenv(otelServiceNameEnvVar, "custom-notification")
|
|
t.Setenv(otelTracesExporterEnvVar, "otlp")
|
|
t.Setenv(otelMetricsExporterEnvVar, "otlp")
|
|
t.Setenv(otelExporterOTLPProtocolEnvVar, "grpc")
|
|
t.Setenv(otelStdoutTracesEnabledEnvVar, "true")
|
|
t.Setenv(otelStdoutMetricsEnabledEnvVar, "true")
|
|
|
|
cfg, err := LoadFromEnv()
|
|
require.NoError(t, err)
|
|
|
|
require.Equal(t, 9*time.Second, cfg.ShutdownTimeout)
|
|
require.Equal(t, "debug", cfg.Logging.Level)
|
|
require.Equal(t, InternalHTTPConfig{
|
|
Addr: "127.0.0.1:18092",
|
|
ReadHeaderTimeout: 3 * time.Second,
|
|
ReadTimeout: 11 * time.Second,
|
|
IdleTimeout: 61 * time.Second,
|
|
}, cfg.InternalHTTP)
|
|
require.Equal(t, RedisConfig{
|
|
Addr: "127.0.0.1:6380",
|
|
Username: "alice",
|
|
Password: "secret",
|
|
DB: 3,
|
|
TLSEnabled: true,
|
|
OperationTimeout: 750 * time.Millisecond,
|
|
}, cfg.Redis)
|
|
require.Equal(t, StreamsConfig{
|
|
Intents: "notification:test_intents",
|
|
GatewayClientEvents: "gateway:test_client-events",
|
|
GatewayClientEventsStreamMaxLen: 2048,
|
|
MailDeliveryCommands: "mail:test_delivery_commands",
|
|
}, cfg.Streams)
|
|
require.Equal(t, 3500*time.Millisecond, cfg.IntentsReadBlockTimeout)
|
|
require.Equal(t, RetryConfig{
|
|
PushMaxAttempts: 5,
|
|
EmailMaxAttempts: 9,
|
|
RouteLeaseTTL: 7 * time.Second,
|
|
RouteBackoffMin: 2 * time.Second,
|
|
RouteBackoffMax: 7 * time.Minute,
|
|
DeadLetterTTL: 120 * time.Hour,
|
|
RecordTTL: 240 * time.Hour,
|
|
IdempotencyTTL: 48 * time.Hour,
|
|
}, cfg.Retry)
|
|
require.Equal(t, UserServiceConfig{
|
|
BaseURL: "https://user-service.internal/api",
|
|
Timeout: 1500 * time.Millisecond,
|
|
}, cfg.UserService)
|
|
require.Equal(t, AdminRoutingConfig{
|
|
GeoReviewRecommended: []string{"first@example.com", "second@example.com"},
|
|
GameGenerationFailed: []string{"ops@example.com"},
|
|
LobbyRuntimePausedAfterStart: []string{"pause@example.com"},
|
|
LobbyApplicationSubmitted: []string{"owner@example.com"},
|
|
}, cfg.AdminRouting)
|
|
require.Equal(t, TelemetryConfig{
|
|
ServiceName: "custom-notification",
|
|
TracesExporter: "otlp",
|
|
MetricsExporter: "otlp",
|
|
TracesProtocol: "grpc",
|
|
MetricsProtocol: "grpc",
|
|
StdoutTracesEnabled: true,
|
|
StdoutMetricsEnabled: true,
|
|
}, cfg.Telemetry)
|
|
}
|
|
|
|
func TestLoadFromEnvRejectsInvalidValues(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
envName string
|
|
envVal string
|
|
}{
|
|
{name: "invalid duration", envName: shutdownTimeoutEnvVar, envVal: "later"},
|
|
{name: "invalid log level", envName: logLevelEnvVar, envVal: "verbose"},
|
|
{name: "invalid redis db", envName: redisDBEnvVar, envVal: "db-three"},
|
|
{name: "invalid redis tls", envName: redisTLSEnabledEnvVar, envVal: "sometimes"},
|
|
{name: "invalid push retries", envName: pushRetryMaxAttemptsEnvVar, envVal: "many"},
|
|
{name: "invalid email retries", envName: emailRetryMaxAttemptsEnvVar, envVal: "several"},
|
|
{name: "invalid gateway client events stream max len", envName: gatewayClientEventsStreamMaxEnvVar, envVal: "many"},
|
|
{name: "invalid user service timeout", envName: userServiceTimeoutEnvVar, envVal: "soon"},
|
|
{name: "invalid intents read block timeout", envName: intentsReadBlockTimeoutEnvVar, envVal: "later"},
|
|
{name: "invalid route lease ttl", envName: routeLeaseTTLEnvVar, envVal: "eventually"},
|
|
{name: "invalid traces exporter", envName: otelTracesExporterEnvVar, envVal: "stdout"},
|
|
{name: "invalid metrics protocol", envName: otelExporterOTLPMetricsProtocolEnvVar, envVal: "udp"},
|
|
{name: "invalid stdout traces", envName: otelStdoutTracesEnabledEnvVar, envVal: "sometimes"},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
tt := tt
|
|
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
t.Setenv(redisAddrEnvVar, "127.0.0.1:6379")
|
|
t.Setenv(userServiceBaseURLEnvVar, "http://user-service.internal")
|
|
t.Setenv(tt.envName, tt.envVal)
|
|
|
|
_, err := LoadFromEnv()
|
|
require.Error(t, err)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestLoadFromEnvRejectsMissingRequiredValues(t *testing.T) {
|
|
t.Run("missing redis addr", func(t *testing.T) {
|
|
t.Setenv(userServiceBaseURLEnvVar, "http://user-service.internal")
|
|
|
|
_, err := LoadFromEnv()
|
|
require.Error(t, err)
|
|
require.Contains(t, err.Error(), redisAddrEnvVar)
|
|
})
|
|
|
|
t.Run("missing user service base url", func(t *testing.T) {
|
|
t.Setenv(redisAddrEnvVar, "127.0.0.1:6379")
|
|
|
|
_, err := LoadFromEnv()
|
|
require.Error(t, err)
|
|
require.Contains(t, err.Error(), userServiceBaseURLEnvVar)
|
|
})
|
|
}
|
|
|
|
func TestLoadFromEnvRejectsInvalidConfiguration(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
envName string
|
|
envVal string
|
|
want string
|
|
}{
|
|
{name: "invalid internal http addr", envName: internalHTTPAddrEnvVar, envVal: "127.0.0.1", want: "internal HTTP addr"},
|
|
{name: "invalid redis addr", envName: redisAddrEnvVar, envVal: "127.0.0.1", want: "redis addr"},
|
|
{name: "relative user service url", envName: userServiceBaseURLEnvVar, envVal: "/internal/users", want: "absolute http(s) URL"},
|
|
{name: "invalid admin email", envName: adminEmailsGeoReviewRecommendedEnvVar, envVal: "broken-email", want: "invalid email address"},
|
|
{name: "blank admin email slot", envName: adminEmailsGameGenerationFailedEnvVar, envVal: "ops@example.com, , second@example.com", want: "must not be empty"},
|
|
{name: "invalid public application admin email", envName: adminEmailsLobbyApplicationSubmittedEnvVar, envVal: "Owner <owner@example.com>", want: "must not include a display name"},
|
|
{name: "nonpositive gateway client events stream max len", envName: gatewayClientEventsStreamMaxEnvVar, envVal: "0", want: "must be positive"},
|
|
{name: "backoff min above max", envName: routeBackoffMinEnvVar, envVal: "10m", want: "must not exceed"},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
tt := tt
|
|
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
t.Setenv(redisAddrEnvVar, "127.0.0.1:6379")
|
|
t.Setenv(userServiceBaseURLEnvVar, "http://user-service.internal")
|
|
t.Setenv(routeBackoffMaxEnvVar, "5m")
|
|
t.Setenv(tt.envName, tt.envVal)
|
|
|
|
_, err := LoadFromEnv()
|
|
require.Error(t, err)
|
|
require.Contains(t, err.Error(), tt.want)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestLoadFromEnvRejectsNonPositiveValues(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
envName string
|
|
envVal string
|
|
}{
|
|
{name: "shutdown timeout", envName: shutdownTimeoutEnvVar, envVal: "0s"},
|
|
{name: "read header timeout", envName: internalHTTPReadHeaderTimeoutEnvVar, envVal: "0s"},
|
|
{name: "read timeout", envName: internalHTTPReadTimeoutEnvVar, envVal: "0s"},
|
|
{name: "idle timeout", envName: internalHTTPIdleTimeoutEnvVar, envVal: "0s"},
|
|
{name: "redis timeout", envName: redisOperationTimeoutEnvVar, envVal: "0s"},
|
|
{name: "intents read block timeout", envName: intentsReadBlockTimeoutEnvVar, envVal: "0s"},
|
|
{name: "push retries", envName: pushRetryMaxAttemptsEnvVar, envVal: "0"},
|
|
{name: "email retries", envName: emailRetryMaxAttemptsEnvVar, envVal: "0"},
|
|
{name: "gateway client events stream max len", envName: gatewayClientEventsStreamMaxEnvVar, envVal: "0"},
|
|
{name: "route lease ttl", envName: routeLeaseTTLEnvVar, envVal: "0s"},
|
|
{name: "route backoff min", envName: routeBackoffMinEnvVar, envVal: "0s"},
|
|
{name: "route backoff max", envName: routeBackoffMaxEnvVar, envVal: "0s"},
|
|
{name: "dead letter ttl", envName: deadLetterTTLEnvVar, envVal: "0s"},
|
|
{name: "record ttl", envName: recordTTLEnvVar, envVal: "0s"},
|
|
{name: "idempotency ttl", envName: idempotencyTTLEnvVar, envVal: "0s"},
|
|
{name: "user service timeout", envName: userServiceTimeoutEnvVar, envVal: "0s"},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
tt := tt
|
|
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
t.Setenv(redisAddrEnvVar, "127.0.0.1:6379")
|
|
t.Setenv(userServiceBaseURLEnvVar, "http://user-service.internal")
|
|
t.Setenv(tt.envName, tt.envVal)
|
|
|
|
_, err := LoadFromEnv()
|
|
require.Error(t, err)
|
|
})
|
|
}
|
|
}
|