You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
437 lines
9.7 KiB
Go
437 lines
9.7 KiB
Go
package utils
|
|
|
|
import (
|
|
"os"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func TestFormatTime(t *testing.T) {
|
|
testTime := time.Date(2024, 8, 20, 15, 30, 45, 0, time.UTC)
|
|
expected := "2024-08-20T15:30:45Z"
|
|
|
|
result := FormatTime(testTime)
|
|
|
|
if result != expected {
|
|
t.Errorf("FormatTime() = %v, want %v", result, expected)
|
|
}
|
|
}
|
|
|
|
func TestGetEnvOrDefault(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
key string
|
|
envValue string
|
|
defaultValue string
|
|
expected string
|
|
setEnv bool
|
|
}{
|
|
{
|
|
name: "Environment variable exists",
|
|
key: "TEST_VAR_EXISTS",
|
|
envValue: "env_value",
|
|
defaultValue: "default_value",
|
|
expected: "env_value",
|
|
setEnv: true,
|
|
},
|
|
{
|
|
name: "Environment variable doesn't exist",
|
|
key: "TEST_VAR_NOT_EXISTS",
|
|
defaultValue: "default_value",
|
|
expected: "default_value",
|
|
setEnv: false,
|
|
},
|
|
{
|
|
name: "Environment variable is empty string",
|
|
key: "TEST_VAR_EMPTY",
|
|
envValue: "",
|
|
defaultValue: "default_value",
|
|
expected: "default_value",
|
|
setEnv: true,
|
|
},
|
|
{
|
|
name: "Environment variable has whitespace",
|
|
key: "TEST_VAR_WHITESPACE",
|
|
envValue: " value ",
|
|
defaultValue: "default_value",
|
|
expected: " value ",
|
|
setEnv: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
// Clean up environment
|
|
os.Unsetenv(tt.key)
|
|
|
|
// Set environment variable if needed
|
|
if tt.setEnv {
|
|
os.Setenv(tt.key, tt.envValue)
|
|
defer os.Unsetenv(tt.key)
|
|
}
|
|
|
|
result := GetEnvOrDefault(tt.key, tt.defaultValue)
|
|
|
|
if result != tt.expected {
|
|
t.Errorf("GetEnvOrDefault(%q, %q) = %v, want %v", tt.key, tt.defaultValue, result, tt.expected)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestGetEnvOrDefaultInt(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
key string
|
|
envValue string
|
|
defaultValue int
|
|
expected int
|
|
setEnv bool
|
|
}{
|
|
{
|
|
name: "Valid integer environment variable",
|
|
key: "TEST_INT_VALID",
|
|
envValue: "42",
|
|
defaultValue: 10,
|
|
expected: 42,
|
|
setEnv: true,
|
|
},
|
|
{
|
|
name: "Invalid integer environment variable",
|
|
key: "TEST_INT_INVALID",
|
|
envValue: "not_a_number",
|
|
defaultValue: 10,
|
|
expected: 10,
|
|
setEnv: true,
|
|
},
|
|
{
|
|
name: "Environment variable doesn't exist",
|
|
key: "TEST_INT_NOT_EXISTS",
|
|
defaultValue: 10,
|
|
expected: 10,
|
|
setEnv: false,
|
|
},
|
|
{
|
|
name: "Negative integer",
|
|
key: "TEST_INT_NEGATIVE",
|
|
envValue: "-123",
|
|
defaultValue: 10,
|
|
expected: -123,
|
|
setEnv: true,
|
|
},
|
|
{
|
|
name: "Zero value",
|
|
key: "TEST_INT_ZERO",
|
|
envValue: "0",
|
|
defaultValue: 10,
|
|
expected: 0,
|
|
setEnv: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
// Clean up environment
|
|
os.Unsetenv(tt.key)
|
|
|
|
// Set environment variable if needed
|
|
if tt.setEnv {
|
|
os.Setenv(tt.key, tt.envValue)
|
|
defer os.Unsetenv(tt.key)
|
|
}
|
|
|
|
result := GetEnvOrDefaultInt(tt.key, tt.defaultValue)
|
|
|
|
if result != tt.expected {
|
|
t.Errorf("GetEnvOrDefaultInt(%q, %d) = %v, want %v", tt.key, tt.defaultValue, result, tt.expected)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestGetEnvOrDefaultBool(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
key string
|
|
envValue string
|
|
defaultValue bool
|
|
expected bool
|
|
setEnv bool
|
|
}{
|
|
{
|
|
name: "True boolean",
|
|
key: "TEST_BOOL_TRUE",
|
|
envValue: "true",
|
|
defaultValue: false,
|
|
expected: true,
|
|
setEnv: true,
|
|
},
|
|
{
|
|
name: "False boolean",
|
|
key: "TEST_BOOL_FALSE",
|
|
envValue: "false",
|
|
defaultValue: true,
|
|
expected: false,
|
|
setEnv: true,
|
|
},
|
|
{
|
|
name: "1 as true",
|
|
key: "TEST_BOOL_ONE",
|
|
envValue: "1",
|
|
defaultValue: false,
|
|
expected: true,
|
|
setEnv: true,
|
|
},
|
|
{
|
|
name: "0 as false",
|
|
key: "TEST_BOOL_ZERO",
|
|
envValue: "0",
|
|
defaultValue: true,
|
|
expected: false,
|
|
setEnv: true,
|
|
},
|
|
{
|
|
name: "Invalid boolean",
|
|
key: "TEST_BOOL_INVALID",
|
|
envValue: "maybe",
|
|
defaultValue: true,
|
|
expected: true,
|
|
setEnv: true,
|
|
},
|
|
{
|
|
name: "Environment variable doesn't exist",
|
|
key: "TEST_BOOL_NOT_EXISTS",
|
|
defaultValue: false,
|
|
expected: false,
|
|
setEnv: false,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
// Clean up environment
|
|
os.Unsetenv(tt.key)
|
|
|
|
// Set environment variable if needed
|
|
if tt.setEnv {
|
|
os.Setenv(tt.key, tt.envValue)
|
|
defer os.Unsetenv(tt.key)
|
|
}
|
|
|
|
result := GetEnvOrDefaultBool(tt.key, tt.defaultValue)
|
|
|
|
if result != tt.expected {
|
|
t.Errorf("GetEnvOrDefaultBool(%q, %v) = %v, want %v", tt.key, tt.defaultValue, result, tt.expected)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestGetEnvOrDefaultDuration(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
key string
|
|
envValue string
|
|
defaultValue time.Duration
|
|
expected time.Duration
|
|
setEnv bool
|
|
}{
|
|
{
|
|
name: "Valid duration in seconds",
|
|
key: "TEST_DURATION_SECONDS",
|
|
envValue: "30s",
|
|
defaultValue: 10 * time.Second,
|
|
expected: 30 * time.Second,
|
|
setEnv: true,
|
|
},
|
|
{
|
|
name: "Valid duration in minutes",
|
|
key: "TEST_DURATION_MINUTES",
|
|
envValue: "5m",
|
|
defaultValue: 1 * time.Minute,
|
|
expected: 5 * time.Minute,
|
|
setEnv: true,
|
|
},
|
|
{
|
|
name: "Valid duration in hours",
|
|
key: "TEST_DURATION_HOURS",
|
|
envValue: "2h",
|
|
defaultValue: 1 * time.Hour,
|
|
expected: 2 * time.Hour,
|
|
setEnv: true,
|
|
},
|
|
{
|
|
name: "Invalid duration format",
|
|
key: "TEST_DURATION_INVALID",
|
|
envValue: "not_a_duration",
|
|
defaultValue: 10 * time.Second,
|
|
expected: 10 * time.Second,
|
|
setEnv: true,
|
|
},
|
|
{
|
|
name: "Environment variable doesn't exist",
|
|
key: "TEST_DURATION_NOT_EXISTS",
|
|
defaultValue: 5 * time.Minute,
|
|
expected: 5 * time.Minute,
|
|
setEnv: false,
|
|
},
|
|
{
|
|
name: "Complex duration",
|
|
key: "TEST_DURATION_COMPLEX",
|
|
envValue: "1h30m45s",
|
|
defaultValue: 1 * time.Second,
|
|
expected: 1*time.Hour + 30*time.Minute + 45*time.Second,
|
|
setEnv: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
// Clean up environment
|
|
os.Unsetenv(tt.key)
|
|
|
|
// Set environment variable if needed
|
|
if tt.setEnv {
|
|
os.Setenv(tt.key, tt.envValue)
|
|
defer os.Unsetenv(tt.key)
|
|
}
|
|
|
|
result := GetEnvOrDefaultDuration(tt.key, tt.defaultValue)
|
|
|
|
if result != tt.expected {
|
|
t.Errorf("GetEnvOrDefaultDuration(%q, %v) = %v, want %v", tt.key, tt.defaultValue, result, tt.expected)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestMustGetEnv(t *testing.T) {
|
|
t.Run("Environment variable exists", func(t *testing.T) {
|
|
key := "TEST_MUST_EXISTS"
|
|
value := "required_value"
|
|
|
|
os.Setenv(key, value)
|
|
defer os.Unsetenv(key)
|
|
|
|
result := MustGetEnv(key)
|
|
|
|
if result != value {
|
|
t.Errorf("MustGetEnv(%q) = %v, want %v", key, result, value)
|
|
}
|
|
})
|
|
|
|
t.Run("Environment variable doesn't exist - should panic", func(t *testing.T) {
|
|
key := "TEST_MUST_NOT_EXISTS"
|
|
|
|
// Ensure the environment variable doesn't exist
|
|
os.Unsetenv(key)
|
|
|
|
defer func() {
|
|
if r := recover(); r == nil {
|
|
t.Errorf("MustGetEnv(%q) should have panicked but didn't", key)
|
|
} else {
|
|
expectedMsg := "Required environment variable not set: " + key
|
|
if r != expectedMsg {
|
|
t.Errorf("MustGetEnv(%q) panic message = %v, want %v", key, r, expectedMsg)
|
|
}
|
|
}
|
|
}()
|
|
|
|
MustGetEnv(key)
|
|
})
|
|
|
|
t.Run("Environment variable is empty - should panic", func(t *testing.T) {
|
|
key := "TEST_MUST_EMPTY"
|
|
|
|
os.Setenv(key, "")
|
|
defer os.Unsetenv(key)
|
|
|
|
defer func() {
|
|
if r := recover(); r == nil {
|
|
t.Errorf("MustGetEnv(%q) should have panicked for empty value but didn't", key)
|
|
}
|
|
}()
|
|
|
|
MustGetEnv(key)
|
|
})
|
|
}
|
|
|
|
func TestIsEnvSet(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
key string
|
|
envValue string
|
|
expected bool
|
|
setEnv bool
|
|
}{
|
|
{
|
|
name: "Environment variable exists with value",
|
|
key: "TEST_IS_SET_VALUE",
|
|
envValue: "some_value",
|
|
expected: true,
|
|
setEnv: true,
|
|
},
|
|
{
|
|
name: "Environment variable exists but empty",
|
|
key: "TEST_IS_SET_EMPTY",
|
|
envValue: "",
|
|
expected: true,
|
|
setEnv: true,
|
|
},
|
|
{
|
|
name: "Environment variable doesn't exist",
|
|
key: "TEST_IS_SET_NOT_EXISTS",
|
|
expected: false,
|
|
setEnv: false,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
// Clean up environment
|
|
os.Unsetenv(tt.key)
|
|
|
|
// Set environment variable if needed
|
|
if tt.setEnv {
|
|
os.Setenv(tt.key, tt.envValue)
|
|
defer os.Unsetenv(tt.key)
|
|
}
|
|
|
|
result := IsEnvSet(tt.key)
|
|
|
|
if result != tt.expected {
|
|
t.Errorf("IsEnvSet(%q) = %v, want %v", tt.key, result, tt.expected)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// BenchmarkGetEnvOrDefault benchmarks the GetEnvOrDefault function
|
|
func BenchmarkGetEnvOrDefault(b *testing.B) {
|
|
key := "BENCHMARK_TEST_VAR"
|
|
value := "benchmark_value"
|
|
defaultValue := "default_value"
|
|
|
|
os.Setenv(key, value)
|
|
defer os.Unsetenv(key)
|
|
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
GetEnvOrDefault(key, defaultValue)
|
|
}
|
|
}
|
|
|
|
// BenchmarkGetEnvOrDefaultInt benchmarks the GetEnvOrDefaultInt function
|
|
func BenchmarkGetEnvOrDefaultInt(b *testing.B) {
|
|
key := "BENCHMARK_TEST_INT_VAR"
|
|
value := "42"
|
|
defaultValue := 10
|
|
|
|
os.Setenv(key, value)
|
|
defer os.Unsetenv(key)
|
|
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
GetEnvOrDefaultInt(key, defaultValue)
|
|
}
|
|
} |