Authorization/redisclient/redis_test.go

package redisclient

import (
	"context"
	"os"
	"testing"
	"time"

	"github.com/alicebob/miniredis/v2"
	"github.com/redis/go-redis/v9"
)

func TestInitDefaultValues(t *testing.T) {
	// Save original values
	originalHost := os.Getenv("REDIS_HOST")
	originalPort := os.Getenv("REDIS_PORT")
	originalPassword := os.Getenv("REDIS_PASSWORD")
	originalRDB := RDB

	defer func() {
		os.Setenv("REDIS_HOST", originalHost)
		os.Setenv("REDIS_PORT", originalPort)
		os.Setenv("REDIS_PASSWORD", originalPassword)
		RDB = originalRDB
	}()

	// Clear environment variables
	os.Unsetenv("REDIS_HOST")
	os.Unsetenv("REDIS_PORT")
	os.Unsetenv("REDIS_PASSWORD")

	// Start a mini redis server for testing
	mr, err := miniredis.Run()
	if err != nil {
		t.Fatalf("Failed to start miniredis: %v", err)
	}
	defer mr.Close()

	// Set environment to use miniredis
	os.Setenv("REDIS_HOST", mr.Host())
	os.Setenv("REDIS_PORT", mr.Port())

	// Initialize Redis client
	Init()

	if RDB == nil {
		t.Error("Expected RDB to be initialized")
	}

	// Test connection
	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
	defer cancel()
	_, err = RDB.Ping(ctx).Result()
	if err != nil {
		t.Errorf("Expected successful ping, got error: %v", err)
	}
}

func TestInit_WithPassword(t *testing.T) {
	// Save original values
	originalHost := os.Getenv("REDIS_HOST")
	originalPort := os.Getenv("REDIS_PORT")
	originalPassword := os.Getenv("REDIS_PASSWORD")
	originalRDB := RDB

	defer func() {
		os.Setenv("REDIS_HOST", originalHost)
		os.Setenv("REDIS_PORT", originalPort)
		os.Setenv("REDIS_PASSWORD", originalPassword)
		RDB = originalRDB
	}()

	// Start a mini redis server
	mr, err := miniredis.Run()
	if err != nil {
		t.Fatalf("Failed to start miniredis: %v", err)
	}
	defer mr.Close()

	// Set password on miniredis
	mr.RequireAuth("testpassword")

	// Set environment variables
	os.Setenv("REDIS_HOST", mr.Host())
	os.Setenv("REDIS_PORT", mr.Port())
	os.Setenv("REDIS_PASSWORD", "testpassword")

	// Initialize Redis client
	Init()

	if RDB == nil {
		t.Error("Expected RDB to be initialized")
	}

	// Test connection with password
	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
	defer cancel()
	_, err = RDB.Ping(ctx).Result()
	if err != nil {
		t.Errorf("Expected successful ping with password, got error: %v", err)
	}
}

func TestInit_CustomHostAndPort(t *testing.T) {
	// Save original values
	originalHost := os.Getenv("REDIS_HOST")
	originalPort := os.Getenv("REDIS_PORT")
	originalPassword := os.Getenv("REDIS_PASSWORD")
	originalRDB := RDB

	defer func() {
		os.Setenv("REDIS_HOST", originalHost)
		os.Setenv("REDIS_PORT", originalPort)
		os.Setenv("REDIS_PASSWORD", originalPassword)
		RDB = originalRDB
	}()

	// Start a mini redis server
	mr, err := miniredis.Run()
	if err != nil {
		t.Fatalf("Failed to start miniredis: %v", err)
	}
	defer mr.Close()

	// Set custom host and port
	os.Setenv("REDIS_HOST", mr.Host())
	os.Setenv("REDIS_PORT", mr.Port())
	os.Unsetenv("REDIS_PASSWORD")

	// Initialize Redis client
	Init()

	if RDB == nil {
		t.Error("Expected RDB to be initialized")
	}

	// Verify the client is configured correctly
	opts := RDB.Options()
	expectedAddr := mr.Addr()
	if opts.Addr != expectedAddr {
		t.Errorf("Expected address '%s', got '%s'", expectedAddr, opts.Addr)
	}
}

func TestInit_ConnectionFailure(t *testing.T) {
	// Save original values
	originalHost := os.Getenv("REDIS_HOST")
	originalPort := os.Getenv("REDIS_PORT")
	originalPassword := os.Getenv("REDIS_PASSWORD")
	originalRDB := RDB

	defer func() {
		os.Setenv("REDIS_HOST", originalHost)
		os.Setenv("REDIS_PORT", originalPort)
		os.Setenv("REDIS_PASSWORD", originalPassword)
		RDB = originalRDB
	}()

	// Set to invalid host/port
	os.Setenv("REDIS_HOST", "invalid-host-that-does-not-exist")
	os.Setenv("REDIS_PORT", "9999")
	os.Unsetenv("REDIS_PASSWORD")

	// This should panic
	defer func() {
		if r := recover(); r == nil {
			t.Error("Expected Init to panic on connection failure")
		}
	}()

	Init()
}

func TestInit_SecuritySettings(t *testing.T) {
	// Save original values
	originalHost := os.Getenv("REDIS_HOST")
	originalPort := os.Getenv("REDIS_PORT")
	originalPassword := os.Getenv("REDIS_PASSWORD")
	originalRDB := RDB

	defer func() {
		os.Setenv("REDIS_HOST", originalHost)
		os.Setenv("REDIS_PORT", originalPort)
		os.Setenv("REDIS_PASSWORD", originalPassword)
		RDB = originalRDB
	}()

	// Start a mini redis server
	mr, err := miniredis.Run()
	if err != nil {
		t.Fatalf("Failed to start miniredis: %v", err)
	}
	defer mr.Close()

	os.Setenv("REDIS_HOST", mr.Host())
	os.Setenv("REDIS_PORT", mr.Port())
	os.Unsetenv("REDIS_PASSWORD")

	// Initialize Redis client
	Init()

	// Verify security settings
	opts := RDB.Options()
	if !opts.DisableIndentity {
		t.Error("Expected DisableIndentity to be true")
	}
	if opts.IdentitySuffix != "" {
		t.Error("Expected IdentitySuffix to be empty")
	}
}

func TestInit_DBNumber(t *testing.T) {
	// Save original values
	originalHost := os.Getenv("REDIS_HOST")
	originalPort := os.Getenv("REDIS_PORT")
	originalPassword := os.Getenv("REDIS_PASSWORD")
	originalRDB := RDB

	defer func() {
		os.Setenv("REDIS_HOST", originalHost)
		os.Setenv("REDIS_PORT", originalPort)
		os.Setenv("REDIS_PASSWORD", originalPassword)
		RDB = originalRDB
	}()

	// Start a mini redis server
	mr, err := miniredis.Run()
	if err != nil {
		t.Fatalf("Failed to start miniredis: %v", err)
	}
	defer mr.Close()

	os.Setenv("REDIS_HOST", mr.Host())
	os.Setenv("REDIS_PORT", mr.Port())
	os.Unsetenv("REDIS_PASSWORD")

	// Initialize Redis client
	Init()

	// Verify DB is set to 0
	opts := RDB.Options()
	if opts.DB != 0 {
		t.Errorf("Expected DB to be 0, got %d", opts.DB)
	}
}

func TestRDB_GlobalVariable(t *testing.T) {
	// Test that RDB is a package-level variable
	originalRDB := RDB
	defer func() { RDB = originalRDB }()

	// Create a test client
	testClient := redis.NewClient(&redis.Options{
		Addr: "localhost:6379",
	})
	defer testClient.Close()

	// Set the global variable
	RDB = testClient

	if RDB != testClient {
		t.Error("Failed to set global RDB variable")
	}
}

func TestInit_EnvironmentDefaults(t *testing.T) {
	tests := []struct {
		name             string
		redisHost        string
		redisPort        string
		redisPassword    string
		expectedHost     string
		expectedPort     string
		expectedPassword string
	}{
		{
			name:             "All defaults",
			redisHost:        "",
			redisPort:        "",
			redisPassword:    "",
			expectedHost:     "localhost",
			expectedPort:     "6379",
			expectedPassword: "",
		},
		{
			name:             "Custom host, default port",
			redisHost:        "redis.example.com",
			redisPort:        "",
			redisPassword:    "",
			expectedHost:     "redis.example.com",
			expectedPort:     "6379",
			expectedPassword: "",
		},
		{
			name:             "All custom",
			redisHost:        "redis.example.com",
			redisPort:        "6380",
			redisPassword:    "secret",
			expectedHost:     "redis.example.com",
			expectedPort:     "6380",
			expectedPassword: "secret",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			// Setup
			if tt.redisHost != "" {
				os.Setenv("REDIS_HOST", tt.redisHost)
			} else {
				os.Unsetenv("REDIS_HOST")
			}
			if tt.redisPort != "" {
				os.Setenv("REDIS_PORT", tt.redisPort)
			} else {
				os.Unsetenv("REDIS_PORT")
			}
			if tt.redisPassword != "" {
				os.Setenv("REDIS_PASSWORD", tt.redisPassword)
			} else {
				os.Unsetenv("REDIS_PASSWORD")
			}

			// Get values (simulating what Init does)
			host := os.Getenv("REDIS_HOST")
			if host == "" {
				host = "localhost"
			}
			port := os.Getenv("REDIS_PORT")
			if port == "" {
				port = "6379"
			}
			password := os.Getenv("REDIS_PASSWORD")
			if password == "" {
				password = ""
			}

			// Verify
			if host != tt.expectedHost {
				t.Errorf("Expected host '%s', got '%s'", tt.expectedHost, host)
			}
			if port != tt.expectedPort {
				t.Errorf("Expected port '%s', got '%s'", tt.expectedPort, port)
			}
			if password != tt.expectedPassword {
				t.Errorf("Expected password '%s', got '%s'", tt.expectedPassword, password)
			}
		})
	}
}

// Additional comprehensive test cases

func TestInit_SetGetOperations(t *testing.T) {
	originalRDB := RDB
	defer func() { RDB = originalRDB }()

	mr, err := miniredis.Run()
	if err != nil {
		t.Fatalf("Failed to start miniredis: %v", err)
	}
	defer mr.Close()

	os.Setenv("REDIS_HOST", mr.Host())
	os.Setenv("REDIS_PORT", mr.Port())
	defer func() {
		os.Unsetenv("REDIS_HOST")
		os.Unsetenv("REDIS_PORT")
	}()

	Init()

	ctx := context.Background()

	// Set a value
	err = RDB.Set(ctx, "test_key", "test_value", time.Minute).Err()
	if err != nil {
		t.Errorf("Failed to set value: %v", err)
	}

	// Get the value
	val, err := RDB.Get(ctx, "test_key").Result()
	if err != nil {
		t.Errorf("Failed to get value: %v", err)
	}
	if val != "test_value" {
		t.Errorf("Expected 'test_value', got '%s'", val)
	}
}

func TestInit_KeyExpiration(t *testing.T) {
	originalRDB := RDB
	defer func() { RDB = originalRDB }()

	mr, err := miniredis.Run()
	if err != nil {
		t.Fatalf("Failed to start miniredis: %v", err)
	}
	defer mr.Close()

	os.Setenv("REDIS_HOST", mr.Host())
	os.Setenv("REDIS_PORT", mr.Port())
	defer func() {
		os.Unsetenv("REDIS_HOST")
		os.Unsetenv("REDIS_PORT")
	}()

	Init()

	ctx := context.Background()

	// Set a key with short expiration
	err = RDB.Set(ctx, "expire_key", "value", 100*time.Millisecond).Err()
	if err != nil {
		t.Errorf("Failed to set value: %v", err)
	}

	// Fast forward time in miniredis
	mr.FastForward(200 * time.Millisecond)

	// Try to get expired key
	_, err = RDB.Get(ctx, "expire_key").Result()
	if err != redis.Nil {
		t.Error("Expected key to be expired")
	}
}

func TestInit_MultipleKeys(t *testing.T) {
	originalRDB := RDB
	defer func() { RDB = originalRDB }()

	mr, err := miniredis.Run()
	if err != nil {
		t.Fatalf("Failed to start miniredis: %v", err)
	}
	defer mr.Close()

	os.Setenv("REDIS_HOST", mr.Host())
	os.Setenv("REDIS_PORT", mr.Port())
	defer func() {
		os.Unsetenv("REDIS_HOST")
		os.Unsetenv("REDIS_PORT")
	}()

	Init()

	ctx := context.Background()

	// Set multiple keys
	keys := map[string]string{
		"key1": "value1",
		"key2": "value2",
		"key3": "value3",
	}

	for key, val := range keys {
		err := RDB.Set(ctx, key, val, time.Minute).Err()
		if err != nil {
			t.Errorf("Failed to set %s: %v", key, err)
		}
	}

	// Verify all keys
	for key, expectedVal := range keys {
		val, err := RDB.Get(ctx, key).Result()
		if err != nil {
			t.Errorf("Failed to get %s: %v", key, err)
		}
		if val != expectedVal {
			t.Errorf("For key %s, expected '%s', got '%s'", key, expectedVal, val)
		}
	}
}

func TestInit_DeleteOperation(t *testing.T) {
	originalRDB := RDB
	defer func() { RDB = originalRDB }()

	mr, err := miniredis.Run()
	if err != nil {
		t.Fatalf("Failed to start miniredis: %v", err)
	}
	defer mr.Close()

	os.Setenv("REDIS_HOST", mr.Host())
	os.Setenv("REDIS_PORT", mr.Port())
	defer func() {
		os.Unsetenv("REDIS_HOST")
		os.Unsetenv("REDIS_PORT")
	}()

	Init()

	ctx := context.Background()

	// Set and then delete
	RDB.Set(ctx, "delete_me", "value", time.Minute)

	err = RDB.Del(ctx, "delete_me").Err()
	if err != nil {
		t.Errorf("Failed to delete key: %v", err)
	}

	// Verify deletion
	_, err = RDB.Get(ctx, "delete_me").Result()
	if err != redis.Nil {
		t.Error("Expected key to be deleted")
	}
}

func TestInit_LargeValue(t *testing.T) {
	originalRDB := RDB
	defer func() { RDB = originalRDB }()

	mr, err := miniredis.Run()
	if err != nil {
		t.Fatalf("Failed to start miniredis: %v", err)
	}
	defer mr.Close()

	os.Setenv("REDIS_HOST", mr.Host())
	os.Setenv("REDIS_PORT", mr.Port())
	defer func() {
		os.Unsetenv("REDIS_HOST")
		os.Unsetenv("REDIS_PORT")
	}()

	Init()

	ctx := context.Background()

	// Create large value (10KB)
	largeValue := string(make([]byte, 10000))
	for i := range largeValue {
		largeValue = largeValue[:i] + "a" + largeValue[i+1:]
	}

	err = RDB.Set(ctx, "large_key", largeValue, time.Minute).Err()
	if err != nil {
		t.Errorf("Failed to set large value: %v", err)
	}

	val, err := RDB.Get(ctx, "large_key").Result()
	if err != nil {
		t.Errorf("Failed to get large value: %v", err)
	}
	if len(val) != 10000 {
		t.Errorf("Expected value length 10000, got %d", len(val))
	}
}

func TestInit_SpecialCharactersInKey(t *testing.T) {
	originalRDB := RDB
	defer func() { RDB = originalRDB }()

	mr, err := miniredis.Run()
	if err != nil {
		t.Fatalf("Failed to start miniredis: %v", err)
	}
	defer mr.Close()

	os.Setenv("REDIS_HOST", mr.Host())
	os.Setenv("REDIS_PORT", mr.Port())
	defer func() {
		os.Unsetenv("REDIS_HOST")
		os.Unsetenv("REDIS_PORT")
	}()

	Init()

	ctx := context.Background()

	specialKeys := []string{
		"key:with:colons",
		"key/with/slashes",
		"key-with-dashes",
		"key_with_underscores",
		"key.with.dots",
	}

	for _, key := range specialKeys {
		err := RDB.Set(ctx, key, "value", time.Minute).Err()
		if err != nil {
			t.Errorf("Failed to set key '%s': %v", key, err)
		}

		val, err := RDB.Get(ctx, key).Result()
		if err != nil {
			t.Errorf("Failed to get key '%s': %v", key, err)
		}
		if val != "value" {
			t.Errorf("For key '%s', expected 'value', got '%s'", key, val)
		}
	}
}

func TestInit_ConcurrentOperations(t *testing.T) {
	originalRDB := RDB
	defer func() { RDB = originalRDB }()

	mr, err := miniredis.Run()
	if err != nil {
		t.Fatalf("Failed to start miniredis: %v", err)
	}
	defer mr.Close()

	os.Setenv("REDIS_HOST", mr.Host())
	os.Setenv("REDIS_PORT", mr.Port())
	defer func() {
		os.Unsetenv("REDIS_HOST")
		os.Unsetenv("REDIS_PORT")
	}()

	Init()

	ctx := context.Background()
	concurrency := 50
	done := make(chan bool, concurrency)

	for i := 0; i < concurrency; i++ {
		go func(idx int) {
			key := "concurrent_key_" + string(rune(idx))
			val := "value_" + string(rune(idx))

			err := RDB.Set(ctx, key, val, time.Minute).Err()
			if err != nil {
				t.Errorf("Failed to set in goroutine %d: %v", idx, err)
			}

			retrieved, err := RDB.Get(ctx, key).Result()
			if err != nil {
				t.Errorf("Failed to get in goroutine %d: %v", idx, err)
			}
			if retrieved != val {
				t.Errorf("Goroutine %d: expected '%s', got '%s'", idx, val, retrieved)
			}

			done <- true
		}(i)
	}

	for i := 0; i < concurrency; i++ {
		<-done
	}
}

func TestInit_ExistsOperation(t *testing.T) {
	originalRDB := RDB
	defer func() { RDB = originalRDB }()

	mr, err := miniredis.Run()
	if err != nil {
		t.Fatalf("Failed to start miniredis: %v", err)
	}
	defer mr.Close()

	os.Setenv("REDIS_HOST", mr.Host())
	os.Setenv("REDIS_PORT", mr.Port())
	defer func() {
		os.Unsetenv("REDIS_HOST")
		os.Unsetenv("REDIS_PORT")
	}()

	Init()

	ctx := context.Background()

	// Check non-existent key
	exists, err := RDB.Exists(ctx, "nonexistent").Result()
	if err != nil {
		t.Errorf("Exists check failed: %v", err)
	}
	if exists != 0 {
		t.Error("Expected key to not exist")
	}

	// Set key and check again
	RDB.Set(ctx, "exists_key", "value", time.Minute)

	exists, err = RDB.Exists(ctx, "exists_key").Result()
	if err != nil {
		t.Errorf("Exists check failed: %v", err)
	}
	if exists != 1 {
		t.Error("Expected key to exist")
	}
}

func TestInit_TTLOperation(t *testing.T) {
	originalRDB := RDB
	defer func() { RDB = originalRDB }()

	mr, err := miniredis.Run()
	if err != nil {
		t.Fatalf("Failed to start miniredis: %v", err)
	}
	defer mr.Close()

	os.Setenv("REDIS_HOST", mr.Host())
	os.Setenv("REDIS_PORT", mr.Port())
	defer func() {
		os.Unsetenv("REDIS_HOST")
		os.Unsetenv("REDIS_PORT")
	}()

	Init()

	ctx := context.Background()

	// Set key with TTL
	RDB.Set(ctx, "ttl_key", "value", time.Hour)

	// Check TTL
	ttl, err := RDB.TTL(ctx, "ttl_key").Result()
	if err != nil {
		t.Errorf("TTL check failed: %v", err)
	}
	if ttl <= 0 {
		t.Errorf("Expected positive TTL, got %v", ttl)
	}
}

func TestInit_InvalidPortFormat(t *testing.T) {
	originalRDB := RDB
	defer func() { RDB = originalRDB }()

	os.Setenv("REDIS_HOST", "localhost")
	os.Setenv("REDIS_PORT", "invalid_port")
	defer func() {
		os.Unsetenv("REDIS_HOST")
		os.Unsetenv("REDIS_PORT")
	}()

	// Init will panic when it can't connect with invalid port (expected behavior)
	defer func() {
		if r := recover(); r != nil {
			t.Logf("Init panicked as expected with invalid port: %v", r)
			// This is expected - Init() panics on connection failure
		} else {
			t.Error("Init should panic with invalid port format")
		}
	}()

	Init()
}

func TestInit_EmptyHostAndPort(t *testing.T) {
	originalRDB := RDB
	defer func() { RDB = originalRDB }()

	os.Setenv("REDIS_HOST", "")
	os.Setenv("REDIS_PORT", "")
	defer func() {
		os.Unsetenv("REDIS_HOST")
		os.Unsetenv("REDIS_PORT")
	}()

	// Will use defaults (localhost:6379) which may not be available, causing panic
	defer func() {
		if r := recover(); r != nil {
			t.Logf("Init panicked (expected if Redis not running locally): %v", r)
			// This is expected behavior if Redis is not available
		} else {
			// If no panic, Redis must be running locally
			if RDB == nil {
				t.Error("RDB should be initialized if Init didn't panic")
			} else {
				t.Log("Init succeeded - Redis is available on localhost:6379")
			}
		}
	}()

	Init()
}