Add job package

internal/job/job_test.go

@@ -0,0 +1,229 @@
+package job
+
+import (
+	"log/slog"
+	"testing"
+	"time"
+)
+
+func TestConfigValidate(t *testing.T) {
+	tests := []struct {
+		name    string
+		config  Config
+		wantErr bool
+	}{
+		{
+			name:    "empty config",
+			config:  Config{},
+			wantErr: true,
+		},
+		{
+			name: "missing name",
+			config: Config{
+				Schedule: "0 9 * * *",
+				Task:     "do something",
+			},
+			wantErr: true,
+		},
+		{
+			name: "missing task",
+			config: Config{
+				Name:     "test",
+				Schedule: "0 9 * * *",
+			},
+			wantErr: true,
+		},
+		{
+			name: "missing schedule",
+			config: Config{
+				Name: "test",
+				Task: "do something",
+			},
+			wantErr: true,
+		},
+		{
+			name: "negative max iterations",
+			config: Config{
+				Name:          "test",
+				Task:          "do something",
+				Schedule:      "0 9 * * *",
+				MaxIterations: -1,
+			},
+			wantErr: true,
+		},
+		{
+			name: "minimal valid config",
+			config: Config{
+				Name:     "test",
+				Task:     "do something",
+				Schedule: "0 9 * * *",
+			},
+			wantErr: false,
+		},
+		{
+			name: "full valid config",
+			config: Config{
+				Name:          "test",
+				Task:          "do something",
+				Schedule:      "0 9 * * *",
+				Timeout:       "10m",
+				MaxIterations: 20,
+				SystemMessage: "You are an assistant.",
+			},
+			wantErr: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := tt.config.Validate()
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Validate() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestConfigIsEnabled(t *testing.T) {
+	// nil enabled → defaults to true
+	cfg := Config{Name: "test"}
+	if !cfg.IsEnabled() {
+		t.Error("expected nil enabled to be true")
+	}
+
+	// explicit true
+	enabled := true
+	cfg.Enabled = &enabled
+	if !cfg.IsEnabled() {
+		t.Error("expected explicit true")
+	}
+
+	// explicit false
+	disabled := false
+	cfg.Enabled = &disabled
+	if cfg.IsEnabled() {
+		t.Error("expected explicit false")
+	}
+}
+
+func TestConfigMaxIterations(t *testing.T) {
+	// Zero means unlimited
+	cfg := Config{Name: "test"}
+	if got := cfg.MaxIterations; got != 0 {
+		t.Errorf("default max iterations = %d, want 0", got)
+	}
+
+	cfg.MaxIterations = 0
+	if got := cfg.MaxIterations; got != 0 {
+		t.Errorf("explicit zero max iterations = %d, want 0", got)
+	}
+
+	// Positive value passes through
+	cfg.MaxIterations = 25
+	if got := cfg.MaxIterations; got != 25 {
+		t.Errorf("custom max iterations = %d, want 25", got)
+	}
+}
+
+func TestConfigTimeout(t *testing.T) {
+	cfg := Config{Name: "test"}
+	if cfg.Timeout != "" {
+		t.Errorf("default timeout = %q, want empty", cfg.Timeout)
+	}
+
+	cfg.Timeout = "10m"
+	got, err := time.ParseDuration(cfg.Timeout)
+	if err != nil {
+		t.Fatalf("ParseDuration(%q) error = %v", cfg.Timeout, err)
+	}
+	if got.Minutes() != 10 {
+		t.Errorf("parsed timeout = %v, want 10m", got)
+	}
+}
+
+func TestNew(t *testing.T) {
+	cfg := Config{
+		Name:          "test",
+		Task:          "do something",
+		Schedule:      "0 9 * * *",
+		Timeout:       "10m",
+		MaxIterations: 20,
+		SystemMessage: "You are an assistant.",
+	}
+
+	j, err := New(cfg, slog.Default(), nil)
+	if err != nil {
+		t.Fatalf("New() error = %v", err)
+	}
+
+	if j.Name() != "test" {
+		t.Errorf("Name() = %q, want %q", j.Name(), "test")
+	}
+	if j.Schedule() != "0 9 * * *" {
+		t.Errorf("Schedule() = %q, want %q", j.Schedule(), "0 9 * * *")
+	}
+	if !j.IsEnabled() {
+		t.Error("IsEnabled() = false, want true")
+	}
+	if j.SystemMessage() != "You are an assistant." {
+		t.Errorf("SystemMessage() = %q, want %q", j.SystemMessage(), "You are an assistant.")
+	}
+	if j.Task() != "do something" {
+		t.Errorf("Task() = %q, want %q", j.Task(), "do something")
+	}
+	if j.Timeout().Minutes() != 10 {
+		t.Errorf("Timeout() = %v, want 10m", j.Timeout())
+	}
+	if j.MaxIterations() != 20 {
+		t.Errorf("MaxIterations() = %d, want 20", j.MaxIterations())
+	}
+	if j.Cron() == nil {
+		t.Error("Cron() = nil, want non-nil")
+	}
+}
+
+func TestNew_Disabled(t *testing.T) {
+	disabled := false
+	cfg := Config{
+		Name:     "test",
+		Task:     "do something",
+		Schedule: "0 9 * * *",
+		Enabled:  &disabled,
+	}
+
+	j, err := New(cfg, slog.Default(), nil)
+	if err != nil {
+		t.Fatalf("New() error = %v", err)
+	}
+
+	if j.IsEnabled() {
+		t.Error("IsEnabled() = true, want false")
+	}
+}
+
+func TestNew_InvalidSchedule(t *testing.T) {
+	cfg := Config{
+		Name:     "test",
+		Task:     "do something",
+		Schedule: "not-a-cron",
+	}
+
+	_, err := New(cfg, slog.Default(), nil)
+	if err == nil {
+		t.Fatal("New() expected error for invalid schedule")
+	}
+}
+
+func TestNew_InvalidTimeout(t *testing.T) {
+	cfg := Config{
+		Name:     "test",
+		Task:     "do something",
+		Schedule: "0 9 * * *",
+		Timeout:  "not-a-duration",
+	}
+
+	_, err := New(cfg, slog.Default(), nil)
+	if err == nil {
+		t.Fatal("New() expected error for invalid timeout")
+	}
+}