craxpert_test.go

package main

import (
	"context"
	"testing"
)

// --- FSM & Job creation tests ---

func TestNewJob_SetsPending(t *testing.T) {
	job := NewJob(1)
	if job.Status != Pending {
		t.Errorf("NewJob: expected Pending, got %v", job.Status)
	}
}

func TestNewJob_SetsMaxRetry(t *testing.T) {
	job := NewJob(1)
	if job.MaxRetry != 3 {
		t.Errorf("NewJob: expected MaxRetry=3, got %d", job.MaxRetry)
	}
}

func TestNewJob_SetsID(t *testing.T) {
	job := NewJob(42)
	if job.ID != 42 {
		t.Errorf("NewJob: expected ID=42, got %d", job.ID)
	}
}

func TestNewJob_TypeCycles(t *testing.T) {
	types := make(map[string]int)
	for i := 0; i < 100; i++ {
		job := NewJob(i)
		types[job.Type]++
	}
	if len(types) != 3 {
		t.Errorf("expected 3 job types, got %d: %v", len(types), types)
	}
}

func TestJobString_ValidJSON(t *testing.T) {
	job := NewJob(1)
	s := job.String()
	if len(s) == 0 {
		t.Fatal("String() returned empty")
	}
	if s[0] != '{' || s[len(s)-1] != '}' {
		t.Errorf("String() does not look like JSON: %s", s)
	}
}

func TestJobStatus_ValidTransitionPendingToRunning(t *testing.T) {
	job := NewJob(1)
	job.Status = Running
	if job.Status != Running {
		t.Errorf("expected Running, got %v", job.Status)
	}
}

func TestJobStatus_ValidTransitionRunningToFailed(t *testing.T) {
	job := NewJob(1)
	job.Status = Running
	job.Status = Failed
	if job.Status != Failed {
		t.Errorf("expected Failed, got %v", job.Status)
	}
}

func TestJobStatus_ValidTransitionRunningToSuccess(t *testing.T) {
	job := NewJob(1)
	job.Status = Running
	job.Status = Success
	if job.Status != Success {
		t.Errorf("expected Success, got %v", job.Status)
	}
}

func TestJobStatus_ValidTransitionFailedToRetrying(t *testing.T) {
	job := NewJob(1)
	job.Status = Failed
	job.Status = Retrying
	if job.Status != Retrying {
		t.Errorf("expected Retrying, got %v", job.Status)
	}
}

// --- Global job map concurrency ---

func TestJobMapConcurrentReadWrite(t *testing.T) {
	JobMutex.Lock()
	jobMap = make(map[int]*Job)
	JobMutex.Unlock()

	done := make(chan bool, 10)
	for i := 0; i < 10; i++ {
		go func(id int) {
			job := NewJob(id)
			JobMutex.Lock()
			jobMap[id] = job
			JobMutex.Unlock()
			done <- true
		}(i)
	}
	for i := 0; i < 10; i++ {
		<-done
	}

	JobMutex.RLock()
	count := len(jobMap)
	JobMutex.RUnlock()
	if count != 10 {
		t.Errorf("expected 10 jobs in map, got %d", count)
	}
}

func TestJobMapConcurrentReadWrite_RaceDetection(t *testing.T) {
	JobMutex.Lock()
	jobMap = make(map[int]*Job)
	JobMutex.Unlock()

	for i := 0; i < 100; i++ {
		go func(id int) {
			job := NewJob(id)
			JobMutex.Lock()
			jobMap[id] = job
			JobMutex.Unlock()
		}(i)
		go func() {
			JobMutex.RLock()
			_ = len(jobMap)
			JobMutex.RUnlock()
		}()

		go func(id int) {
			JobMutex.RLock()
			_, ok := jobMap[id]
			JobMutex.RUnlock()
			_ = ok
		}(i)
	}
}

func TestJobMapReadUnderLock(t *testing.T) {
	JobMutex.Lock()
	jobMap = make(map[int]*Job)
	jobMap[1] = NewJob(1)
	JobMutex.Unlock()

	JobMutex.RLock()
	job, ok := jobMap[1]
	JobMutex.RUnlock()

	if !ok {
		t.Error("expected to find job 1")
	}
	if job.Status != Pending {
		t.Errorf("expected Pending, got %v", job.Status)
	}
}

func TestJobMapDelete(t *testing.T) {
	JobMutex.Lock()
	jobMap = make(map[int]*Job)
	jobMap[1] = NewJob(1)
	JobMutex.Unlock()

	JobMutex.Lock()
	delete(jobMap, 1)
	JobMutex.Unlock()

	JobMutex.RLock()
	_, ok := jobMap[1]
	JobMutex.RUnlock()
	if ok {
		t.Error("expected job 1 to be deleted")
	}
}

// --- Pool tests ---

func TestNewPool_CreatesCorrectSize(t *testing.T) {
	pool := NewPool(5)
	if pool.Size() != 5 {
		t.Errorf("NewPool: expected size 5, got %d", pool.Size())
	}
}

func TestNewPool_InitialSizeZero(t *testing.T) {
	pool := NewPool(0)
	if pool.Size() != 0 {
		t.Errorf("NewPool: expected size 0, got %d", pool.Size())
	}
}

func TestPoolResize_Increase(t *testing.T) {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	pool := NewPool(2)
	pool.Start(ctx)
	defer pool.Stop()

	pool.Resize(ctx, 5)
	if pool.Size() != 5 {
		t.Errorf("Resize up: expected size 5, got %d", pool.Size())
	}
}

func TestPoolResize_Decrease(t *testing.T) {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	pool := NewPool(5)
	pool.Start(ctx)
	defer pool.Stop()

	pool.Resize(ctx, 2)
	if pool.Size() != 2 {
		t.Errorf("Resize down: expected size 2, got %d", pool.Size())
	}
}

func TestPoolSubmit_JobQueued(t *testing.T) {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	pool := NewPool(1)
	pool.Start(ctx)
	defer pool.Stop()

	job := NewJob(1)
	pool.Submit(job)
}

func TestPoolStop_NoPanic(t *testing.T) {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	pool := NewPool(3)
	pool.Start(ctx)
	pool.Stop()
}

func TestPoolDoubleStop_NoPanic(t *testing.T) {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	pool := NewPool(3)
	pool.Start(ctx)
	pool.Stop()
}

func TestPoolGracefulShutdown_NoDeadlock(t *testing.T) {
	pool := NewPool(5)
	ctx, cancel := context.WithCancel(context.Background())

	pool.Start(ctx)
	for i := 0; i < 20; i++ {
		pool.Submit(NewJob(i))
	}

	cancel()
	pool.Stop()
}

func TestPoolMultipleSubmit_RaceFree(t *testing.T) {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	pool := NewPool(3)
	pool.Start(ctx)
	defer pool.Stop()

	for i := 0; i < 50; i++ {
		go pool.Submit(NewJob(i))
	}
}

// --- HTTP handler tests ---

func TestHandleReset_ClearsMap(t *testing.T) {
	JobMutex.Lock()
	jobMap = make(map[int]*Job)
	jobMap[1] = NewJob(1)
	JobMutex.Unlock()

	oldActive := autoGeneratorActive
	autoGeneratorActive = true

	JobMutex.Lock()
	jobMap = make(map[int]*Job)
	JobMutex.Unlock()

	JobMutex.RLock()
	count := len(jobMap)
	JobMutex.RUnlock()
	if count != 0 {
		t.Errorf("Reset: expected empty map, got %d entries", count)
	}

	autoGeneratorActive = oldActive
}

func TestHandleToggleAuto_Toggles(t *testing.T) {
	original := autoGeneratorActive
	autoGeneratorActive = true
	if autoGeneratorActive != true {
		t.Error("expected true initially")
	}

	original2 := autoGeneratorActive
	autoGeneratorActive = !autoGeneratorActive
	if autoGeneratorActive != false {
		t.Error("expected false after toggle")
	}
	autoGeneratorActive = original2

	autoGeneratorActive = !autoGeneratorActive
	if autoGeneratorActive != false {
		t.Error("expected false after second toggle")
	}

	autoGeneratorActive = original
}

func TestHandleJobStop_NotFound(t *testing.T) {
	JobMutex.Lock()
	jobMap = make(map[int]*Job)
	JobMutex.Unlock()

	_, ok := jobMap[999]
	if ok {
		t.Error("expected job 999 to not exist")
	}
}

func TestHandlePoolResize_InvalidSize(t *testing.T) {
	pool := NewPool(3)
	_ = pool.Size()
}

// --- Context cancellation ---

func TestJobCancelFunction_NotNil(t *testing.T) {
	job := NewJob(1)
	if job.Cancel != nil {
		t.Error("new job should have nil cancel func")
	}
}

func TestJobCancelAfterRunning(t *testing.T) {
	job := NewJob(1)
	job.Status = Running
	ctx, cancel := context.WithCancel(context.Background())
	job.Cancel = cancel
	cancel()
	select {
	case <-ctx.Done():
	default:
		t.Error("context should be done after cancel")
	}
}

// --- Retry logic ---

func TestHandleFailure_RetriesWhenBelowMax(t *testing.T) {
	job := NewJob(1)
	job.Attempts = 0
	job.MaxRetry = 3
	job.Status = Failed

	pool := NewPool(1)
	handleFailure(1, job, pool)

	if job.Status != Retrying {
		t.Errorf("handleFailure: expected Retrying when attempts < maxRetry, got %v", job.Status)
	}
}

func TestHandleFailure_FailsWhenExhausted(t *testing.T) {
	job := NewJob(1)
	job.Attempts = 3
	job.MaxRetry = 3
	job.Status = Failed

	pool := NewPool(1)
	handleFailure(1, job, pool)

	if job.Status != Failed {
		t.Errorf("handleFailure: expected Failed when attempts >= maxRetry, got %v", job.Status)
	}
}

func TestHandleFailure_FailsWhenAboveMax(t *testing.T) {
	job := NewJob(1)
	job.Attempts = 5
	job.MaxRetry = 3
	job.Status = Failed

	pool := NewPool(1)
	handleFailure(1, job, pool)

	if job.Status != Failed {
		t.Errorf("handleFailure: expected Failed when attempts > maxRetry, got %v", job.Status)
	}
}

func TestHandleFailure_AttemptIncremented(t *testing.T) {
	job := NewJob(1)
	job.Attempts = 1
	job.MaxRetry = 3
	job.Status = Failed

	pool := NewPool(1)
	handleFailure(1, job, pool)

	if job.Status != Retrying {
		t.Errorf("expected Retrying, got %v", job.Status)
	}
}

func TestHandleFailure_ZeroRetry(t *testing.T) {
	job := NewJob(1)
	job.Attempts = 0
	job.MaxRetry = 0
	job.Status = Failed

	pool := NewPool(1)
	handleFailure(1, job, pool)

	if job.Status != Failed {
		t.Errorf("handleFailure: expected Failed when MaxRetry=0 and attempts >= 0, got %v", job.Status)
	}
}

func TestHandleFailure_ConcurrentInvocations(t *testing.T) {
	pool := NewPool(3)
	for i := 0; i < 10; i++ {
		go func(id int) {
			job := NewJob(id)
			job.Attempts = 0
			job.MaxRetry = 2
			handleFailure(1, job, pool)
		}(i)
	}
}

func TestHandleFailure_ConcurrentExhaustion(t *testing.T) {
	pool := NewPool(3)
	for i := 0; i < 10; i++ {
		go func(id int) {
			job := NewJob(id)
			job.Attempts = 5
			job.MaxRetry = 3
			handleFailure(1, job, pool)
		}(i)
	}
}

// --- Edge case tests ---

func TestZeroIDJob(t *testing.T) {
	job := NewJob(0)
	if job.ID != 0 {
		t.Errorf("expected ID=0, got %d", job.ID)
	}
}

func TestLargeID_TypeCyclesCorrectly(t *testing.T) {
	job := NewJob(100)
	if job.Type != "sms" {
		t.Errorf("expected type sms for ID=100 (100%%3=1), got %s", job.Type)
	}
}

func TestLargeIDJob(t *testing.T) {
	job := NewJob(999999)
	if job.ID != 999999 {
		t.Errorf("expected ID=999999, got %d", job.ID)
	}
}

func TestPayloadNotEmpty(t *testing.T) {
	job := NewJob(1)
	if _, ok := job.Payload["to"]; !ok {
		t.Error("expected payload to have 'to' key")
	}
}

func TestAttemptsStartAtZero(t *testing.T) {
	job := NewJob(1)
	if job.Attempts != 0 {
		t.Errorf("expected Attempts=0, got %d", job.Attempts)
	}
}

func TestJobMapConcurrentDelete(t *testing.T) {
	JobMutex.Lock()
	jobMap = make(map[int]*Job)
	for i := 0; i < 100; i++ {
		jobMap[i] = NewJob(i)
	}
	JobMutex.Unlock()

	for i := 0; i < 100; i++ {
		go func(id int) {
			JobMutex.Lock()
			delete(jobMap, id)
			JobMutex.Unlock()
		}(i)
		go func() {
			JobMutex.RLock()
			_ = len(jobMap)
			JobMutex.RUnlock()
		}()
	}
}