wal_test.go

package main

import (
	"os"
	"testing"
)

func setupWALTest() {
	os.Remove("jobs.log")
	os.Remove("jobs.tmp")
	JobMutex.Lock()
	jobMap = make(map[int]*Job)
	JobMutex.Unlock()
}

func TestWALAppend_CreatesFile(t *testing.T) {
	setupWALTest()
	defer os.Remove("jobs.log")

	job := NewJob(1)
	AppendJobToWAL(job)

	if _, err := os.Stat("jobs.log"); os.IsNotExist(err) {
		t.Fatal("WAL file was not created")
	}
}

func TestWALAppend_WritesJSONLine(t *testing.T) {
	setupWALTest()
	defer os.Remove("jobs.log")

	job := NewJob(1)
	AppendJobToWAL(job)

	data, _ := os.ReadFile("jobs.log")
	if len(data) == 0 {
		t.Fatal("WAL file is empty")
	}
}

func TestWALAppend_MultipleJobs(t *testing.T) {
	setupWALTest()
	defer os.Remove("jobs.log")

	for i := 0; i < 10; i++ {
		AppendJobToWAL(NewJob(i))
	}

	loaded := LoadJobsFromWAL()
	if len(loaded) != 10 {
		t.Errorf("expected 10 jobs from WAL, got %d", len(loaded))
	}
}

func TestWALRecovery_UnfinishedJobsLoaded(t *testing.T) {
	setupWALTest()
	defer os.Remove("jobs.log")

	jobs := []*Job{
		{ID: 1, Status: Pending, MaxRetry: 3},
		{ID: 2, Status: Running, MaxRetry: 3},
		{ID: 3, Status: Success, MaxRetry: 3},
		{ID: 4, Status: Failed, MaxRetry: 3},
		{ID: 5, Status: Retrying, MaxRetry: 3},
	}
	for _, j := range jobs {
		AppendJobToWAL(j)
	}

	loaded := LoadJobsFromWAL()
	loadedIDs := make(map[int]bool)
	for _, j := range loaded {
		loadedIDs[j.ID] = true
	}

	if loadedIDs[3] {
		t.Error("Success job should not be loaded from WAL")
	}
	if loadedIDs[4] {
		t.Error("Failed job should not be loaded from WAL")
	}
	if !loadedIDs[1] {
		t.Error("Pending job should be loaded from WAL")
	}
	if !loadedIDs[2] {
		t.Error("Running job should be loaded from WAL")
	}
	if !loadedIDs[5] {
		t.Error("Retrying job should be loaded from WAL")
	}
}

func TestWALRecovery_EmptyWAL(t *testing.T) {
	setupWALTest()
	defer os.Remove("jobs.log")

	loaded := LoadJobsFromWAL()
	if len(loaded) != 0 {
		t.Errorf("expected 0 jobs from empty WAL, got %d", len(loaded))
	}
}

func TestWALRecovery_NonexistentFile(t *testing.T) {
	os.Remove("jobs.log")
	os.Remove("jobs.tmp")

	loaded := LoadJobsFromWAL()
	if loaded == nil {
		t.Fatal("LoadJobsFromWAL should return empty slice, not nil")
	}
	if len(loaded) != 0 {
		t.Errorf("expected 0 jobs from nonexistent file, got %d", len(loaded))
	}
}

func TestWALAppend_Concurrent(t *testing.T) {
	setupWALTest()
	defer os.Remove("jobs.log")

	done := make(chan bool, 50)
	for i := 0; i < 50; i++ {
		go func(id int) {
			AppendJobToWAL(NewJob(id))
			done <- true
		}(i)
	}
	for i := 0; i < 50; i++ {
		<-done
	}

	loaded := LoadJobsFromWAL()
	if len(loaded) != 50 {
		t.Errorf("expected 50 jobs from concurrent WAL writes, got %d", len(loaded))
	}
}

func TestWALAppend_ConcurrentWithCheckpoint(t *testing.T) {
	setupWALTest()
	defer os.Remove("jobs.log")
	defer os.Remove("jobs.tmp")

	done := make(chan bool, 100)
	for i := 0; i < 100; i++ {
		go func(id int) {
			AppendJobToWAL(NewJob(id))
			done <- true
		}(i)
		if i%10 == 0 {
			go func() {
				Checkpoint()
				done <- true
			}()
		}
	}
	for i := 0; i < 110; i++ {
		<-done
	}
}

func TestCheckpoint_CreatesCompactedFile(t *testing.T) {
	setupWALTest()
	defer os.Remove("jobs.log")
	defer os.Remove("jobs.tmp")

	for i := 0; i < 5; i++ {
		AppendJobToWAL(NewJob(i))
	}

	Checkpoint()

	if _, err := os.Stat("jobs.log"); os.IsNotExist(err) {
		t.Fatal("Checkpoint should recreate jobs.log")
	}
}

func TestCheckpoint_DoesNotLoseActiveJobs(t *testing.T) {
	setupWALTest()
	defer os.Remove("jobs.log")
	defer os.Remove("jobs.tmp")

	for i := 0; i < 5; i++ {
		job := NewJob(i)
		job.Status = Pending
		AppendJobToWAL(job)
	}

	JobMutex.Lock()
	for i := 0; i < 5; i++ {
		job := NewJob(i)
		if i < 3 {
			job.Status = Success
		} else {
			job.Status = Running
		}
		jobMap[i] = job
	}
	JobMutex.Unlock()

	Checkpoint()

	loaded := LoadJobsFromWAL()

	for _, j := range loaded {
		if j.Status == Success {
			t.Errorf("Checkpoint: job %d should not be in compacted WAL (status: %v)", j.ID, j.Status)
		}
	}
}

func TestCheckpoint_Idempotent(t *testing.T) {
	setupWALTest()
	defer os.Remove("jobs.log")
	defer os.Remove("jobs.tmp")

	for i := 0; i < 5; i++ {
		AppendJobToWAL(NewJob(i))
	}

	Checkpoint()
	Checkpoint()
	Checkpoint()

	loaded := LoadJobsFromWAL()
	if len(loaded) == 0 {
		t.Error("Checkpoint should not lose all jobs on multiple invocations")
	}
}

func TestWALJobPersistence_AcrossRestart(t *testing.T) {
	setupWALTest()
	defer os.Remove("jobs.log")

	job1 := NewJob(1)
	job1.Status = Running
	AppendJobToWAL(job1)

	job2 := NewJob(2)
	job2.Status = Pending
	AppendJobToWAL(job2)

	loaded := LoadJobsFromWAL()
	if len(loaded) != 2 {
		t.Errorf("expected 2 jobs from WAL, got %d", len(loaded))
	}

	for _, j := range loaded {
		if j.MaxRetry == 0 {
			t.Errorf("WAL recovery should set default MaxRetry=3 for job %d", j.ID)
		}
	}
}

func TestWALRecovery_CorruptedLine(t *testing.T) {
	setupWALTest()
	defer os.Remove("jobs.log")

	os.WriteFile("jobs.log", []byte("{\"id\":1,\"status\":\"RUNNING\"}\nnot-json-line\n{\"id\":2,\"status\":\"PENDING\"}\n"), 0644)

	loaded := LoadJobsFromWAL()
	if len(loaded) != 2 {
		t.Errorf("expected 2 valid jobs from partially corrupted WAL, got %d", len(loaded))
	}
}

func TestWALAppend_DifferentStatuses(t *testing.T) {
	setupWALTest()
	defer os.Remove("jobs.log")

	states := []JobStatus{Pending, Running, Success, Failed, Retrying}
	for i, s := range states {
		job := NewJob(i)
		job.Status = s
		AppendJobToWAL(job)
	}

	loaded := LoadJobsFromWAL()
	for _, j := range loaded {
		if j.Status != Pending && j.Status != Running && j.Status != Retrying {
			t.Errorf("LoadJobsFromWAL: terminal job %d (status %v) should be filtered out", j.ID, j.Status)
		}
	}
}

func TestCheckpoint_MemoryConsistency(t *testing.T) {
	setupWALTest()
	defer os.Remove("jobs.log")
	defer os.Remove("jobs.tmp")

	JobMutex.Lock()
	for i := 0; i < 10; i++ {
		job := NewJob(i)
		job.Status = Running
		jobMap[i] = job
	}
	JobMutex.Unlock()

	Checkpoint()

	JobMutex.Lock()
	jobMap[5].Status = Success
	JobMutex.Unlock()

	Checkpoint()

	loaded := LoadJobsFromWAL()
	for _, j := range loaded {
		if j.ID == 5 && j.Status == Success {
			t.Error("job 5 should not be in compacted WAL")
		}
	}
}