fetch_ml/tests/unit/config/constants_test.go

package config

import (
	"testing"

	"github.com/jfraeys/fetch_ml/internal/config"
)

func TestDefaultConstants(t *testing.T) {
	t.Parallel() // Enable parallel execution

	// Test default values
	tests := []struct {
		actual   any
		expected any
		name     string
	}{
		{config.DefaultSSHPort, 22, "DefaultSSHPort"},
		{config.DefaultRedisPort, 6379, "DefaultRedisPort"},
		{config.DefaultRedisAddr, "localhost:6379", "DefaultRedisAddr"},
		{config.DefaultBasePath, "/mnt/nas/jobs", "DefaultBasePath"},
		{config.DefaultEntrypoint, "train.py", "DefaultEntrypoint"},
		{config.DefaultDataDir, "/data/active", "DefaultDataDir"},
		{config.DefaultLocalDataDir, "./data/active", "DefaultLocalDataDir"},
		{config.DefaultNASDataDir, "/mnt/datasets", "DefaultNASDataDir"},
		{config.DefaultMaxWorkers, 2, "DefaultMaxWorkers"},
		{config.DefaultPollInterval, 5, "DefaultPollInterval"},
		{config.DefaultMaxAgeHours, 24, "DefaultMaxAgeHours"},
		{config.DefaultMaxSizeGB, 100, "DefaultMaxSizeGB"},
		{config.DefaultCleanupInterval, 60, "DefaultCleanupInterval"},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if tt.actual != tt.expected {
				t.Errorf("Expected %s to be %v, got %v", tt.name, tt.expected, tt.actual)
			}
		})
	}
}

func TestRedisKeyConstants(t *testing.T) {
	t.Parallel() // Enable parallel execution

	// Test Redis key prefixes
	tests := []struct {
		name     string
		actual   string
		expected string
	}{
		{"RedisTaskQueueKey", config.RedisTaskQueueKey, "ml:queue"},
		{"RedisTaskPrefix", config.RedisTaskPrefix, "ml:task:"},
		{"RedisJobMetricsPrefix", config.RedisJobMetricsPrefix, "ml:metrics:"},
		{"RedisTaskStatusPrefix", config.RedisTaskStatusPrefix, "ml:status:"},
		{"RedisWorkerHeartbeat", config.RedisWorkerHeartbeat, "ml:workers:heartbeat"},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if tt.actual != tt.expected {
				t.Errorf("Expected %s to be %s, got %s", tt.name, tt.expected, tt.actual)
			}
		})
	}
}

func TestTaskStatusConstants(t *testing.T) {
	t.Parallel() // Enable parallel execution

	// Test task status constants
	tests := []struct {
		name     string
		actual   string
		expected string
	}{
		{"TaskStatusQueued", config.TaskStatusQueued, "queued"},
		{"TaskStatusRunning", config.TaskStatusRunning, "running"},
		{"TaskStatusCompleted", config.TaskStatusCompleted, "completed"},
		{"TaskStatusFailed", config.TaskStatusFailed, "failed"},
		{"TaskStatusCancelled", config.TaskStatusCancelled, "cancelled"},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if tt.actual != tt.expected {
				t.Errorf("Expected %s to be %s, got %s", tt.name, tt.expected, tt.actual)
			}
		})
	}
}

func TestJobStatusConstants(t *testing.T) {
	t.Parallel() // Enable parallel execution

	// Test job status constants
	tests := []struct {
		name     string
		actual   string
		expected string
	}{
		{"JobStatusPending", config.JobStatusPending, "pending"},
		{"JobStatusQueued", config.JobStatusQueued, "queued"},
		{"JobStatusRunning", config.JobStatusRunning, "running"},
		{"JobStatusFinished", config.JobStatusFinished, "finished"},
		{"JobStatusFailed", config.JobStatusFailed, "failed"},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if tt.actual != tt.expected {
				t.Errorf("Expected %s to be %s, got %s", tt.name, tt.expected, tt.actual)
			}
		})
	}
}

func TestPodmanConstants(t *testing.T) {
	t.Parallel() // Enable parallel execution

	// Test Podman defaults
	tests := []struct {
		name     string
		actual   string
		expected string
	}{
		{"DefaultPodmanMemory", config.DefaultPodmanMemory, "8g"},
		{"DefaultPodmanCPUs", config.DefaultPodmanCPUs, "2"},
		{"DefaultContainerWorkspace", config.DefaultContainerWorkspace, "/workspace"},
		{"DefaultContainerResults", config.DefaultContainerResults, "/workspace/results"},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if tt.actual != tt.expected {
				t.Errorf("Expected %s to be %s, got %s", tt.name, tt.expected, tt.actual)
			}
		})
	}
}

func TestConstantsConsistency(t *testing.T) {
	t.Parallel() // Enable parallel execution

	// Test that related constants are consistent
	if config.DefaultRedisAddr != "localhost:6379" {
		t.Errorf("Expected DefaultRedisAddr to use DefaultRedisPort, got %s", config.DefaultRedisAddr)
	}

	// Test that Redis key prefixes are consistent
	if config.RedisTaskPrefix == config.RedisJobMetricsPrefix {
		t.Error("Redis task prefix and metrics prefix should be different")
	}

	// Test that status constants don't overlap
	taskStatuses := []string{
		config.TaskStatusQueued,
		config.TaskStatusRunning,
		config.TaskStatusCompleted,
		config.TaskStatusFailed,
		config.TaskStatusCancelled,
	}

	jobStatuses := []string{
		config.JobStatusPending,
		config.JobStatusQueued,
		config.JobStatusRunning,
		config.JobStatusFinished,
		config.JobStatusFailed,
	}

	// Check for duplicates within task statuses
	for i, status1 := range taskStatuses {
		for j, status2 := range taskStatuses {
			if i != j && status1 == status2 {
				t.Errorf("Duplicate task status found: %s", status1)
			}
		}
	}

	// Check for duplicates within job statuses
	for i, status1 := range jobStatuses {
		for j, status2 := range jobStatuses {
			if i != j && status1 == status2 {
				t.Errorf("Duplicate job status found: %s", status1)
			}
		}
	}
}